system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp

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

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

#include "goldfish_vk_deepcopy_guest.h"


#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"

#include "vk_util.h"


namespace goldfish_vk {

void deepcopy_extension_struct(
    BumpPool* pool,
    const void* structExtension,
    void* structExtension_out);

#ifdef VK_VERSION_1_0
void deepcopy_VkExtent2D(
    BumpPool* pool,
    const VkExtent2D* from,
    VkExtent2D* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkExtent3D(
    BumpPool* pool,
    const VkExtent3D* from,
    VkExtent3D* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkOffset2D(
    BumpPool* pool,
    const VkOffset2D* from,
    VkOffset2D* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkOffset3D(
    BumpPool* pool,
    const VkOffset3D* from,
    VkOffset3D* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkRect2D(
    BumpPool* pool,
    const VkRect2D* from,
    VkRect2D* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
    deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
}

void deepcopy_VkBaseInStructure(
    BumpPool* pool,
    const VkBaseInStructure* from,
    VkBaseInStructure* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const VkBaseInStructure*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBaseOutStructure(
    BumpPool* pool,
    const VkBaseOutStructure* from,
    VkBaseOutStructure* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (VkBaseOutStructure*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBufferMemoryBarrier(
    BumpPool* pool,
    const VkBufferMemoryBarrier* from,
    VkBufferMemoryBarrier* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDispatchIndirectCommand(
    BumpPool* pool,
    const VkDispatchIndirectCommand* from,
    VkDispatchIndirectCommand* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDrawIndexedIndirectCommand(
    BumpPool* pool,
    const VkDrawIndexedIndirectCommand* from,
    VkDrawIndexedIndirectCommand* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDrawIndirectCommand(
    BumpPool* pool,
    const VkDrawIndirectCommand* from,
    VkDrawIndirectCommand* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkImageSubresourceRange(
    BumpPool* pool,
    const VkImageSubresourceRange* from,
    VkImageSubresourceRange* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkImageMemoryBarrier(
    BumpPool* pool,
    const VkImageMemoryBarrier* from,
    VkImageMemoryBarrier* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
}

void deepcopy_VkMemoryBarrier(
    BumpPool* pool,
    const VkMemoryBarrier* from,
    VkMemoryBarrier* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAllocationCallbacks(
    BumpPool* pool,
    const VkAllocationCallbacks* from,
    VkAllocationCallbacks* to)
{
    (void)pool;
    *to = *from;
    to->pUserData = nullptr;
    if (from->pUserData)
    {
        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
    }
}

void deepcopy_VkApplicationInfo(
    BumpPool* pool,
    const VkApplicationInfo* from,
    VkApplicationInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pApplicationName = nullptr;
    if (from->pApplicationName)
    {
        to->pApplicationName = pool->strDup(from->pApplicationName);
    }
    to->pEngineName = nullptr;
    if (from->pEngineName)
    {
        to->pEngineName = pool->strDup(from->pEngineName);
    }
}

void deepcopy_VkFormatProperties(
    BumpPool* pool,
    const VkFormatProperties* from,
    VkFormatProperties* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkImageFormatProperties(
    BumpPool* pool,
    const VkImageFormatProperties* from,
    VkImageFormatProperties* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkExtent3D(pool, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
}

void deepcopy_VkInstanceCreateInfo(
    BumpPool* pool,
    const VkInstanceCreateInfo* from,
    VkInstanceCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pApplicationInfo = nullptr;
    if (from->pApplicationInfo)
    {
        to->pApplicationInfo = (VkApplicationInfo*)pool->alloc(sizeof(const VkApplicationInfo));
        deepcopy_VkApplicationInfo(pool, from->pApplicationInfo, (VkApplicationInfo*)(to->pApplicationInfo));
    }
    to->ppEnabledLayerNames = nullptr;
    if (from->ppEnabledLayerNames && from->enabledLayerCount)
    {
        to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
    }
    to->ppEnabledExtensionNames = nullptr;
    if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
    {
        to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
    }
}

void deepcopy_VkMemoryHeap(
    BumpPool* pool,
    const VkMemoryHeap* from,
    VkMemoryHeap* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkMemoryType(
    BumpPool* pool,
    const VkMemoryType* from,
    VkMemoryType* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPhysicalDeviceFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceFeatures* from,
    VkPhysicalDeviceFeatures* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPhysicalDeviceLimits(
    BumpPool* pool,
    const VkPhysicalDeviceLimits* from,
    VkPhysicalDeviceLimits* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->maxComputeWorkGroupCount, from->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
    memcpy(to->maxComputeWorkGroupSize, from->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
    memcpy(to->maxViewportDimensions, from->maxViewportDimensions, 2 * sizeof(uint32_t));
    memcpy(to->viewportBoundsRange, from->viewportBoundsRange, 2 * sizeof(float));
    memcpy(to->pointSizeRange, from->pointSizeRange, 2 * sizeof(float));
    memcpy(to->lineWidthRange, from->lineWidthRange, 2 * sizeof(float));
}

void deepcopy_VkPhysicalDeviceMemoryProperties(
    BumpPool* pool,
    const VkPhysicalDeviceMemoryProperties* from,
    VkPhysicalDeviceMemoryProperties* to)
{
    (void)pool;
    *to = *from;
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
    {
        deepcopy_VkMemoryType(pool, from->memoryTypes + i, (VkMemoryType*)(to->memoryTypes + i));
    }
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
    {
        deepcopy_VkMemoryHeap(pool, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
    }
}

void deepcopy_VkPhysicalDeviceSparseProperties(
    BumpPool* pool,
    const VkPhysicalDeviceSparseProperties* from,
    VkPhysicalDeviceSparseProperties* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPhysicalDeviceProperties(
    BumpPool* pool,
    const VkPhysicalDeviceProperties* from,
    VkPhysicalDeviceProperties* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->deviceName, from->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
    memcpy(to->pipelineCacheUUID, from->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    deepcopy_VkPhysicalDeviceLimits(pool, &from->limits, (VkPhysicalDeviceLimits*)(&to->limits));
    deepcopy_VkPhysicalDeviceSparseProperties(pool, &from->sparseProperties, (VkPhysicalDeviceSparseProperties*)(&to->sparseProperties));
}

void deepcopy_VkQueueFamilyProperties(
    BumpPool* pool,
    const VkQueueFamilyProperties* from,
    VkQueueFamilyProperties* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkExtent3D(pool, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
}

void deepcopy_VkDeviceQueueCreateInfo(
    BumpPool* pool,
    const VkDeviceQueueCreateInfo* from,
    VkDeviceQueueCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pQueuePriorities = nullptr;
    if (from->pQueuePriorities)
    {
        to->pQueuePriorities = (float*)pool->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
    }
}

void deepcopy_VkDeviceCreateInfo(
    BumpPool* pool,
    const VkDeviceCreateInfo* from,
    VkDeviceCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pQueueCreateInfos = nullptr;
        if (from->pQueueCreateInfos)
        {
            to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)pool->alloc(from->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
            to->queueCreateInfoCount = from->queueCreateInfoCount;
            for (uint32_t i = 0; i < (uint32_t)from->queueCreateInfoCount; ++i)
            {
                deepcopy_VkDeviceQueueCreateInfo(pool, from->pQueueCreateInfos + i, (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
            }
        }
    }
    to->ppEnabledLayerNames = nullptr;
    if (from->ppEnabledLayerNames && from->enabledLayerCount)
    {
        to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
    }
    to->ppEnabledExtensionNames = nullptr;
    if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
    {
        to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
    }
    to->pEnabledFeatures = nullptr;
    if (from->pEnabledFeatures)
    {
        to->pEnabledFeatures = (VkPhysicalDeviceFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceFeatures));
        deepcopy_VkPhysicalDeviceFeatures(pool, from->pEnabledFeatures, (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
    }
}

void deepcopy_VkExtensionProperties(
    BumpPool* pool,
    const VkExtensionProperties* from,
    VkExtensionProperties* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->extensionName, from->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}

void deepcopy_VkLayerProperties(
    BumpPool* pool,
    const VkLayerProperties* from,
    VkLayerProperties* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->layerName, from->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void deepcopy_VkSubmitInfo(
    BumpPool* pool,
    const VkSubmitInfo* from,
    VkSubmitInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphores = nullptr;
    if (from->pWaitSemaphores)
    {
        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
    }
    to->pWaitDstStageMask = nullptr;
    if (from->pWaitDstStageMask)
    {
        to->pWaitDstStageMask = (VkPipelineStageFlags*)pool->dupArray(from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
    }
    to->pCommandBuffers = nullptr;
    if (from->pCommandBuffers)
    {
        to->pCommandBuffers = (VkCommandBuffer*)pool->dupArray(from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
    }
    to->pSignalSemaphores = nullptr;
    if (from->pSignalSemaphores)
    {
        to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
    }
}

void deepcopy_VkMappedMemoryRange(
    BumpPool* pool,
    const VkMappedMemoryRange* from,
    VkMappedMemoryRange* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryAllocateInfo(
    BumpPool* pool,
    const VkMemoryAllocateInfo* from,
    VkMemoryAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryRequirements(
    BumpPool* pool,
    const VkMemoryRequirements* from,
    VkMemoryRequirements* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSparseMemoryBind(
    BumpPool* pool,
    const VkSparseMemoryBind* from,
    VkSparseMemoryBind* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSparseBufferMemoryBindInfo(
    BumpPool* pool,
    const VkSparseBufferMemoryBindInfo* from,
    VkSparseBufferMemoryBindInfo* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pBinds = nullptr;
        if (from->pBinds)
        {
            to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
            to->bindCount = from->bindCount;
            for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
            {
                deepcopy_VkSparseMemoryBind(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
            }
        }
    }
}

void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
    BumpPool* pool,
    const VkSparseImageOpaqueMemoryBindInfo* from,
    VkSparseImageOpaqueMemoryBindInfo* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pBinds = nullptr;
        if (from->pBinds)
        {
            to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
            to->bindCount = from->bindCount;
            for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
            {
                deepcopy_VkSparseMemoryBind(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
            }
        }
    }
}

void deepcopy_VkImageSubresource(
    BumpPool* pool,
    const VkImageSubresource* from,
    VkImageSubresource* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSparseImageMemoryBind(
    BumpPool* pool,
    const VkSparseImageMemoryBind* from,
    VkSparseImageMemoryBind* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageSubresource(pool, &from->subresource, (VkImageSubresource*)(&to->subresource));
    deepcopy_VkOffset3D(pool, &from->offset, (VkOffset3D*)(&to->offset));
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
}

void deepcopy_VkSparseImageMemoryBindInfo(
    BumpPool* pool,
    const VkSparseImageMemoryBindInfo* from,
    VkSparseImageMemoryBindInfo* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pBinds = nullptr;
        if (from->pBinds)
        {
            to->pBinds = (VkSparseImageMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseImageMemoryBind));
            to->bindCount = from->bindCount;
            for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
            {
                deepcopy_VkSparseImageMemoryBind(pool, from->pBinds + i, (VkSparseImageMemoryBind*)(to->pBinds + i));
            }
        }
    }
}

void deepcopy_VkBindSparseInfo(
    BumpPool* pool,
    const VkBindSparseInfo* from,
    VkBindSparseInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphores = nullptr;
    if (from->pWaitSemaphores)
    {
        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
    }
    if (from)
    {
        to->pBufferBinds = nullptr;
        if (from->pBufferBinds)
        {
            to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)pool->alloc(from->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
            to->bufferBindCount = from->bufferBindCount;
            for (uint32_t i = 0; i < (uint32_t)from->bufferBindCount; ++i)
            {
                deepcopy_VkSparseBufferMemoryBindInfo(pool, from->pBufferBinds + i, (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
            }
        }
    }
    if (from)
    {
        to->pImageOpaqueBinds = nullptr;
        if (from->pImageOpaqueBinds)
        {
            to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)pool->alloc(from->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
            to->imageOpaqueBindCount = from->imageOpaqueBindCount;
            for (uint32_t i = 0; i < (uint32_t)from->imageOpaqueBindCount; ++i)
            {
                deepcopy_VkSparseImageOpaqueMemoryBindInfo(pool, from->pImageOpaqueBinds + i, (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
            }
        }
    }
    if (from)
    {
        to->pImageBinds = nullptr;
        if (from->pImageBinds)
        {
            to->pImageBinds = (VkSparseImageMemoryBindInfo*)pool->alloc(from->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
            to->imageBindCount = from->imageBindCount;
            for (uint32_t i = 0; i < (uint32_t)from->imageBindCount; ++i)
            {
                deepcopy_VkSparseImageMemoryBindInfo(pool, from->pImageBinds + i, (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
            }
        }
    }
    to->pSignalSemaphores = nullptr;
    if (from->pSignalSemaphores)
    {
        to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
    }
}

void deepcopy_VkSparseImageFormatProperties(
    BumpPool* pool,
    const VkSparseImageFormatProperties* from,
    VkSparseImageFormatProperties* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkExtent3D(pool, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
}

void deepcopy_VkSparseImageMemoryRequirements(
    BumpPool* pool,
    const VkSparseImageMemoryRequirements* from,
    VkSparseImageMemoryRequirements* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkSparseImageFormatProperties(pool, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
}

void deepcopy_VkFenceCreateInfo(
    BumpPool* pool,
    const VkFenceCreateInfo* from,
    VkFenceCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSemaphoreCreateInfo(
    BumpPool* pool,
    const VkSemaphoreCreateInfo* from,
    VkSemaphoreCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkEventCreateInfo(
    BumpPool* pool,
    const VkEventCreateInfo* from,
    VkEventCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkQueryPoolCreateInfo(
    BumpPool* pool,
    const VkQueryPoolCreateInfo* from,
    VkQueryPoolCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBufferCreateInfo(
    BumpPool* pool,
    const VkBufferCreateInfo* from,
    VkBufferCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pQueueFamilyIndices = nullptr;
    if (from->pQueueFamilyIndices)
    {
        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkBufferViewCreateInfo(
    BumpPool* pool,
    const VkBufferViewCreateInfo* from,
    VkBufferViewCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImageCreateInfo(
    BumpPool* pool,
    const VkImageCreateInfo* from,
    VkImageCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
    to->pQueueFamilyIndices = nullptr;
    if (from->pQueueFamilyIndices)
    {
        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkSubresourceLayout(
    BumpPool* pool,
    const VkSubresourceLayout* from,
    VkSubresourceLayout* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkComponentMapping(
    BumpPool* pool,
    const VkComponentMapping* from,
    VkComponentMapping* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkImageViewCreateInfo(
    BumpPool* pool,
    const VkImageViewCreateInfo* from,
    VkImageViewCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
    deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
}

void deepcopy_VkShaderModuleCreateInfo(
    BumpPool* pool,
    const VkShaderModuleCreateInfo* from,
    VkShaderModuleCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pCode = nullptr;
    if (from->pCode)
    {
        to->pCode = (uint32_t*)pool->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
    }
}

void deepcopy_VkPipelineCacheCreateInfo(
    BumpPool* pool,
    const VkPipelineCacheCreateInfo* from,
    VkPipelineCacheCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pInitialData = nullptr;
    if (from->pInitialData)
    {
        to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
    }
}

void deepcopy_VkSpecializationMapEntry(
    BumpPool* pool,
    const VkSpecializationMapEntry* from,
    VkSpecializationMapEntry* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSpecializationInfo(
    BumpPool* pool,
    const VkSpecializationInfo* from,
    VkSpecializationInfo* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pMapEntries = nullptr;
        if (from->pMapEntries)
        {
            to->pMapEntries = (VkSpecializationMapEntry*)pool->alloc(from->mapEntryCount * sizeof(const VkSpecializationMapEntry));
            to->mapEntryCount = from->mapEntryCount;
            for (uint32_t i = 0; i < (uint32_t)from->mapEntryCount; ++i)
            {
                deepcopy_VkSpecializationMapEntry(pool, from->pMapEntries + i, (VkSpecializationMapEntry*)(to->pMapEntries + i));
            }
        }
    }
    to->pData = nullptr;
    if (from->pData)
    {
        to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
    }
}

void deepcopy_VkPipelineShaderStageCreateInfo(
    BumpPool* pool,
    const VkPipelineShaderStageCreateInfo* from,
    VkPipelineShaderStageCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pName = nullptr;
    if (from->pName)
    {
        to->pName = pool->strDup(from->pName);
    }
    to->pSpecializationInfo = nullptr;
    if (from->pSpecializationInfo)
    {
        to->pSpecializationInfo = (VkSpecializationInfo*)pool->alloc(sizeof(const VkSpecializationInfo));
        deepcopy_VkSpecializationInfo(pool, from->pSpecializationInfo, (VkSpecializationInfo*)(to->pSpecializationInfo));
    }
}

void deepcopy_VkComputePipelineCreateInfo(
    BumpPool* pool,
    const VkComputePipelineCreateInfo* from,
    VkComputePipelineCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkPipelineShaderStageCreateInfo(pool, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
}

void deepcopy_VkVertexInputBindingDescription(
    BumpPool* pool,
    const VkVertexInputBindingDescription* from,
    VkVertexInputBindingDescription* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkVertexInputAttributeDescription(
    BumpPool* pool,
    const VkVertexInputAttributeDescription* from,
    VkVertexInputAttributeDescription* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineVertexInputStateCreateInfo(
    BumpPool* pool,
    const VkPipelineVertexInputStateCreateInfo* from,
    VkPipelineVertexInputStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pVertexBindingDescriptions = nullptr;
        if (from->pVertexBindingDescriptions)
        {
            to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)pool->alloc(from->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
            to->vertexBindingDescriptionCount = from->vertexBindingDescriptionCount;
            for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDescriptionCount; ++i)
            {
                deepcopy_VkVertexInputBindingDescription(pool, from->pVertexBindingDescriptions + i, (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
            }
        }
    }
    if (from)
    {
        to->pVertexAttributeDescriptions = nullptr;
        if (from->pVertexAttributeDescriptions)
        {
            to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)pool->alloc(from->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
            to->vertexAttributeDescriptionCount = from->vertexAttributeDescriptionCount;
            for (uint32_t i = 0; i < (uint32_t)from->vertexAttributeDescriptionCount; ++i)
            {
                deepcopy_VkVertexInputAttributeDescription(pool, from->pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
            }
        }
    }
}

void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
    BumpPool* pool,
    const VkPipelineInputAssemblyStateCreateInfo* from,
    VkPipelineInputAssemblyStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineTessellationStateCreateInfo(
    BumpPool* pool,
    const VkPipelineTessellationStateCreateInfo* from,
    VkPipelineTessellationStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkViewport(
    BumpPool* pool,
    const VkViewport* from,
    VkViewport* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineViewportStateCreateInfo(
    BumpPool* pool,
    const VkPipelineViewportStateCreateInfo* from,
    VkPipelineViewportStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pViewports = nullptr;
        if (from->pViewports)
        {
            to->pViewports = (VkViewport*)pool->alloc(from->viewportCount * sizeof(const VkViewport));
            to->viewportCount = from->viewportCount;
            for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
            {
                deepcopy_VkViewport(pool, from->pViewports + i, (VkViewport*)(to->pViewports + i));
            }
        }
    }
    if (from)
    {
        to->pScissors = nullptr;
        if (from->pScissors)
        {
            to->pScissors = (VkRect2D*)pool->alloc(from->scissorCount * sizeof(const VkRect2D));
            to->scissorCount = from->scissorCount;
            for (uint32_t i = 0; i < (uint32_t)from->scissorCount; ++i)
            {
                deepcopy_VkRect2D(pool, from->pScissors + i, (VkRect2D*)(to->pScissors + i));
            }
        }
    }
}

void deepcopy_VkPipelineRasterizationStateCreateInfo(
    BumpPool* pool,
    const VkPipelineRasterizationStateCreateInfo* from,
    VkPipelineRasterizationStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineMultisampleStateCreateInfo(
    BumpPool* pool,
    const VkPipelineMultisampleStateCreateInfo* from,
    VkPipelineMultisampleStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pSampleMask = nullptr;
    if (from->pSampleMask)
    {
        to->pSampleMask = (VkSampleMask*)pool->dupArray(from->pSampleMask, (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
    }
}

void deepcopy_VkStencilOpState(
    BumpPool* pool,
    const VkStencilOpState* from,
    VkStencilOpState* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineDepthStencilStateCreateInfo(
    BumpPool* pool,
    const VkPipelineDepthStencilStateCreateInfo* from,
    VkPipelineDepthStencilStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkStencilOpState(pool, &from->front, (VkStencilOpState*)(&to->front));
    deepcopy_VkStencilOpState(pool, &from->back, (VkStencilOpState*)(&to->back));
}

void deepcopy_VkPipelineColorBlendAttachmentState(
    BumpPool* pool,
    const VkPipelineColorBlendAttachmentState* from,
    VkPipelineColorBlendAttachmentState* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineColorBlendStateCreateInfo(
    BumpPool* pool,
    const VkPipelineColorBlendStateCreateInfo* from,
    VkPipelineColorBlendStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAttachments = nullptr;
        if (from->pAttachments)
        {
            to->pAttachments = (VkPipelineColorBlendAttachmentState*)pool->alloc(from->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
            to->attachmentCount = from->attachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
            {
                deepcopy_VkPipelineColorBlendAttachmentState(pool, from->pAttachments + i, (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
            }
        }
    }
    memcpy(to->blendConstants, from->blendConstants, 4 * sizeof(float));
}

void deepcopy_VkPipelineDynamicStateCreateInfo(
    BumpPool* pool,
    const VkPipelineDynamicStateCreateInfo* from,
    VkPipelineDynamicStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDynamicStates = nullptr;
    if (from->pDynamicStates)
    {
        to->pDynamicStates = (VkDynamicState*)pool->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
    }
}

void deepcopy_VkGraphicsPipelineCreateInfo(
    BumpPool* pool,
    const VkGraphicsPipelineCreateInfo* from,
    VkGraphicsPipelineCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pStages = nullptr;
        if (from->pStages)
        {
            to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
            to->stageCount = from->stageCount;
            for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
            {
                deepcopy_VkPipelineShaderStageCreateInfo(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
            }
        }
    }
    to->pVertexInputState = nullptr;
    if (from->pVertexInputState)
    {
        to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
        deepcopy_VkPipelineVertexInputStateCreateInfo(pool, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
    }
    to->pInputAssemblyState = nullptr;
    if (from->pInputAssemblyState)
    {
        to->pInputAssemblyState = (VkPipelineInputAssemblyStateCreateInfo*)pool->alloc(sizeof(const VkPipelineInputAssemblyStateCreateInfo));
        deepcopy_VkPipelineInputAssemblyStateCreateInfo(pool, from->pInputAssemblyState, (VkPipelineInputAssemblyStateCreateInfo*)(to->pInputAssemblyState));
    }
    to->pTessellationState = nullptr;
    if (from->pTessellationState)
    {
        to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
        deepcopy_VkPipelineTessellationStateCreateInfo(pool, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
    }
    to->pViewportState = nullptr;
    if (from->pViewportState)
    {
        to->pViewportState = (VkPipelineViewportStateCreateInfo*)pool->alloc(sizeof(const VkPipelineViewportStateCreateInfo));
        deepcopy_VkPipelineViewportStateCreateInfo(pool, from->pViewportState, (VkPipelineViewportStateCreateInfo*)(to->pViewportState));
    }
    to->pRasterizationState = nullptr;
    if (from->pRasterizationState)
    {
        to->pRasterizationState = (VkPipelineRasterizationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
        deepcopy_VkPipelineRasterizationStateCreateInfo(pool, from->pRasterizationState, (VkPipelineRasterizationStateCreateInfo*)(to->pRasterizationState));
    }
    to->pMultisampleState = nullptr;
    if (from->pMultisampleState)
    {
        to->pMultisampleState = (VkPipelineMultisampleStateCreateInfo*)pool->alloc(sizeof(const VkPipelineMultisampleStateCreateInfo));
        deepcopy_VkPipelineMultisampleStateCreateInfo(pool, from->pMultisampleState, (VkPipelineMultisampleStateCreateInfo*)(to->pMultisampleState));
    }
    to->pDepthStencilState = nullptr;
    if (from->pDepthStencilState)
    {
        to->pDepthStencilState = (VkPipelineDepthStencilStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
        deepcopy_VkPipelineDepthStencilStateCreateInfo(pool, from->pDepthStencilState, (VkPipelineDepthStencilStateCreateInfo*)(to->pDepthStencilState));
    }
    to->pColorBlendState = nullptr;
    if (from->pColorBlendState)
    {
        to->pColorBlendState = (VkPipelineColorBlendStateCreateInfo*)pool->alloc(sizeof(const VkPipelineColorBlendStateCreateInfo));
        deepcopy_VkPipelineColorBlendStateCreateInfo(pool, from->pColorBlendState, (VkPipelineColorBlendStateCreateInfo*)(to->pColorBlendState));
    }
    to->pDynamicState = nullptr;
    if (from->pDynamicState)
    {
        to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
        deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
    }
}

void deepcopy_VkPushConstantRange(
    BumpPool* pool,
    const VkPushConstantRange* from,
    VkPushConstantRange* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineLayoutCreateInfo(
    BumpPool* pool,
    const VkPipelineLayoutCreateInfo* from,
    VkPipelineLayoutCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pSetLayouts = nullptr;
    if (from->pSetLayouts)
    {
        to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
    }
    if (from)
    {
        to->pPushConstantRanges = nullptr;
        if (from->pPushConstantRanges)
        {
            to->pPushConstantRanges = (VkPushConstantRange*)pool->alloc(from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
            to->pushConstantRangeCount = from->pushConstantRangeCount;
            for (uint32_t i = 0; i < (uint32_t)from->pushConstantRangeCount; ++i)
            {
                deepcopy_VkPushConstantRange(pool, from->pPushConstantRanges + i, (VkPushConstantRange*)(to->pPushConstantRanges + i));
            }
        }
    }
}

void deepcopy_VkSamplerCreateInfo(
    BumpPool* pool,
    const VkSamplerCreateInfo* from,
    VkSamplerCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCopyDescriptorSet(
    BumpPool* pool,
    const VkCopyDescriptorSet* from,
    VkCopyDescriptorSet* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDescriptorBufferInfo(
    BumpPool* pool,
    const VkDescriptorBufferInfo* from,
    VkDescriptorBufferInfo* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDescriptorImageInfo(
    BumpPool* pool,
    const VkDescriptorImageInfo* from,
    VkDescriptorImageInfo* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDescriptorPoolSize(
    BumpPool* pool,
    const VkDescriptorPoolSize* from,
    VkDescriptorPoolSize* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDescriptorPoolCreateInfo(
    BumpPool* pool,
    const VkDescriptorPoolCreateInfo* from,
    VkDescriptorPoolCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pPoolSizes = nullptr;
        if (from->pPoolSizes)
        {
            to->pPoolSizes = (VkDescriptorPoolSize*)pool->alloc(from->poolSizeCount * sizeof(const VkDescriptorPoolSize));
            to->poolSizeCount = from->poolSizeCount;
            for (uint32_t i = 0; i < (uint32_t)from->poolSizeCount; ++i)
            {
                deepcopy_VkDescriptorPoolSize(pool, from->pPoolSizes + i, (VkDescriptorPoolSize*)(to->pPoolSizes + i));
            }
        }
    }
}

void deepcopy_VkDescriptorSetAllocateInfo(
    BumpPool* pool,
    const VkDescriptorSetAllocateInfo* from,
    VkDescriptorSetAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pSetLayouts = nullptr;
    if (from->pSetLayouts)
    {
        to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
    }
}

void deepcopy_VkDescriptorSetLayoutBinding(
    BumpPool* pool,
    const VkDescriptorSetLayoutBinding* from,
    VkDescriptorSetLayoutBinding* to)
{
    (void)pool;
    *to = *from;
    to->pImmutableSamplers = nullptr;
    if (from->pImmutableSamplers)
    {
        to->pImmutableSamplers = (VkSampler*)pool->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
    }
}

void deepcopy_VkDescriptorSetLayoutCreateInfo(
    BumpPool* pool,
    const VkDescriptorSetLayoutCreateInfo* from,
    VkDescriptorSetLayoutCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pBindings = nullptr;
        if (from->pBindings)
        {
            to->pBindings = (VkDescriptorSetLayoutBinding*)pool->alloc(from->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
            to->bindingCount = from->bindingCount;
            for (uint32_t i = 0; i < (uint32_t)from->bindingCount; ++i)
            {
                deepcopy_VkDescriptorSetLayoutBinding(pool, from->pBindings + i, (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
            }
        }
    }
}

void deepcopy_VkWriteDescriptorSet(
    BumpPool* pool,
    const VkWriteDescriptorSet* from,
    VkWriteDescriptorSet* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pImageInfo = nullptr;
        if (from->pImageInfo)
        {
            to->pImageInfo = (VkDescriptorImageInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorImageInfo));
            to->descriptorCount = from->descriptorCount;
            for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
            {
                deepcopy_VkDescriptorImageInfo(pool, from->pImageInfo + i, (VkDescriptorImageInfo*)(to->pImageInfo + i));
            }
        }
    }
    if (from)
    {
        to->pBufferInfo = nullptr;
        if (from->pBufferInfo)
        {
            to->pBufferInfo = (VkDescriptorBufferInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorBufferInfo));
            to->descriptorCount = from->descriptorCount;
            for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
            {
                deepcopy_VkDescriptorBufferInfo(pool, from->pBufferInfo + i, (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
            }
        }
    }
    to->pTexelBufferView = nullptr;
    if (from->pTexelBufferView)
    {
        to->pTexelBufferView = (VkBufferView*)pool->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
    }
}

void deepcopy_VkAttachmentDescription(
    BumpPool* pool,
    const VkAttachmentDescription* from,
    VkAttachmentDescription* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkAttachmentReference(
    BumpPool* pool,
    const VkAttachmentReference* from,
    VkAttachmentReference* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkFramebufferCreateInfo(
    BumpPool* pool,
    const VkFramebufferCreateInfo* from,
    VkFramebufferCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttachments = nullptr;
    if (from->pAttachments)
    {
        to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
    }
}

void deepcopy_VkSubpassDescription(
    BumpPool* pool,
    const VkSubpassDescription* from,
    VkSubpassDescription* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pInputAttachments = nullptr;
        if (from->pInputAttachments)
        {
            to->pInputAttachments = (VkAttachmentReference*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference));
            to->inputAttachmentCount = from->inputAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference(pool, from->pInputAttachments + i, (VkAttachmentReference*)(to->pInputAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pColorAttachments = nullptr;
        if (from->pColorAttachments)
        {
            to->pColorAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
            to->colorAttachmentCount = from->colorAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference(pool, from->pColorAttachments + i, (VkAttachmentReference*)(to->pColorAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pResolveAttachments = nullptr;
        if (from->pResolveAttachments)
        {
            to->pResolveAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
            to->colorAttachmentCount = from->colorAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference(pool, from->pResolveAttachments + i, (VkAttachmentReference*)(to->pResolveAttachments + i));
            }
        }
    }
    to->pDepthStencilAttachment = nullptr;
    if (from->pDepthStencilAttachment)
    {
        to->pDepthStencilAttachment = (VkAttachmentReference*)pool->alloc(sizeof(const VkAttachmentReference));
        deepcopy_VkAttachmentReference(pool, from->pDepthStencilAttachment, (VkAttachmentReference*)(to->pDepthStencilAttachment));
    }
    to->pPreserveAttachments = nullptr;
    if (from->pPreserveAttachments)
    {
        to->pPreserveAttachments = (uint32_t*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkSubpassDependency(
    BumpPool* pool,
    const VkSubpassDependency* from,
    VkSubpassDependency* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkRenderPassCreateInfo(
    BumpPool* pool,
    const VkRenderPassCreateInfo* from,
    VkRenderPassCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAttachments = nullptr;
        if (from->pAttachments)
        {
            to->pAttachments = (VkAttachmentDescription*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription));
            to->attachmentCount = from->attachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
            {
                deepcopy_VkAttachmentDescription(pool, from->pAttachments + i, (VkAttachmentDescription*)(to->pAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pSubpasses = nullptr;
        if (from->pSubpasses)
        {
            to->pSubpasses = (VkSubpassDescription*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription));
            to->subpassCount = from->subpassCount;
            for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
            {
                deepcopy_VkSubpassDescription(pool, from->pSubpasses + i, (VkSubpassDescription*)(to->pSubpasses + i));
            }
        }
    }
    if (from)
    {
        to->pDependencies = nullptr;
        if (from->pDependencies)
        {
            to->pDependencies = (VkSubpassDependency*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency));
            to->dependencyCount = from->dependencyCount;
            for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
            {
                deepcopy_VkSubpassDependency(pool, from->pDependencies + i, (VkSubpassDependency*)(to->pDependencies + i));
            }
        }
    }
}

void deepcopy_VkCommandPoolCreateInfo(
    BumpPool* pool,
    const VkCommandPoolCreateInfo* from,
    VkCommandPoolCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCommandBufferAllocateInfo(
    BumpPool* pool,
    const VkCommandBufferAllocateInfo* from,
    VkCommandBufferAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCommandBufferInheritanceInfo(
    BumpPool* pool,
    const VkCommandBufferInheritanceInfo* from,
    VkCommandBufferInheritanceInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCommandBufferBeginInfo(
    BumpPool* pool,
    const VkCommandBufferBeginInfo* from,
    VkCommandBufferBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pInheritanceInfo = nullptr;
    if (from->pInheritanceInfo)
    {
        to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)pool->alloc(sizeof(const VkCommandBufferInheritanceInfo));
        deepcopy_VkCommandBufferInheritanceInfo(pool, from->pInheritanceInfo, (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
    }
}

void deepcopy_VkBufferCopy(
    BumpPool* pool,
    const VkBufferCopy* from,
    VkBufferCopy* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkImageSubresourceLayers(
    BumpPool* pool,
    const VkImageSubresourceLayers* from,
    VkImageSubresourceLayers* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkBufferImageCopy(
    BumpPool* pool,
    const VkBufferImageCopy* from,
    VkBufferImageCopy* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageSubresourceLayers(pool, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
    deepcopy_VkOffset3D(pool, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
    deepcopy_VkExtent3D(pool, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
}

void deepcopy_VkClearColorValue(
    BumpPool* pool,
    const VkClearColorValue* from,
    VkClearColorValue* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->float32, from->float32, 4 * sizeof(float));
    memcpy(to->int32, from->int32, 4 * sizeof(int32_t));
    memcpy(to->uint32, from->uint32, 4 * sizeof(uint32_t));
}

void deepcopy_VkClearDepthStencilValue(
    BumpPool* pool,
    const VkClearDepthStencilValue* from,
    VkClearDepthStencilValue* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkClearValue(
    BumpPool* pool,
    const VkClearValue* from,
    VkClearValue* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkClearColorValue(pool, &from->color, (VkClearColorValue*)(&to->color));
    deepcopy_VkClearDepthStencilValue(pool, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
}

void deepcopy_VkClearAttachment(
    BumpPool* pool,
    const VkClearAttachment* from,
    VkClearAttachment* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkClearValue(pool, &from->clearValue, (VkClearValue*)(&to->clearValue));
}

void deepcopy_VkClearRect(
    BumpPool* pool,
    const VkClearRect* from,
    VkClearRect* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkRect2D(pool, &from->rect, (VkRect2D*)(&to->rect));
}

void deepcopy_VkImageBlit(
    BumpPool* pool,
    const VkImageBlit* from,
    VkImageBlit* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        deepcopy_VkOffset3D(pool, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        deepcopy_VkOffset3D(pool, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
    }
}

void deepcopy_VkImageCopy(
    BumpPool* pool,
    const VkImageCopy* from,
    VkImageCopy* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
}

void deepcopy_VkImageResolve(
    BumpPool* pool,
    const VkImageResolve* from,
    VkImageResolve* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
}

void deepcopy_VkRenderPassBeginInfo(
    BumpPool* pool,
    const VkRenderPassBeginInfo* from,
    VkRenderPassBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
    if (from)
    {
        to->pClearValues = nullptr;
        if (from->pClearValues)
        {
            to->pClearValues = (VkClearValue*)pool->alloc(from->clearValueCount * sizeof(const VkClearValue));
            to->clearValueCount = from->clearValueCount;
            for (uint32_t i = 0; i < (uint32_t)from->clearValueCount; ++i)
            {
                deepcopy_VkClearValue(pool, from->pClearValues + i, (VkClearValue*)(to->pClearValues + i));
            }
        }
    }
}

#endif
#ifdef VK_VERSION_1_1
void deepcopy_VkPhysicalDeviceSubgroupProperties(
    BumpPool* pool,
    const VkPhysicalDeviceSubgroupProperties* from,
    VkPhysicalDeviceSubgroupProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBindBufferMemoryInfo(
    BumpPool* pool,
    const VkBindBufferMemoryInfo* from,
    VkBindBufferMemoryInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBindImageMemoryInfo(
    BumpPool* pool,
    const VkBindImageMemoryInfo* from,
    VkBindImageMemoryInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDevice16BitStorageFeatures(
    BumpPool* pool,
    const VkPhysicalDevice16BitStorageFeatures* from,
    VkPhysicalDevice16BitStorageFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryDedicatedRequirements(
    BumpPool* pool,
    const VkMemoryDedicatedRequirements* from,
    VkMemoryDedicatedRequirements* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryDedicatedAllocateInfo(
    BumpPool* pool,
    const VkMemoryDedicatedAllocateInfo* from,
    VkMemoryDedicatedAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryAllocateFlagsInfo(
    BumpPool* pool,
    const VkMemoryAllocateFlagsInfo* from,
    VkMemoryAllocateFlagsInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceGroupRenderPassBeginInfo(
    BumpPool* pool,
    const VkDeviceGroupRenderPassBeginInfo* from,
    VkDeviceGroupRenderPassBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pDeviceRenderAreas = nullptr;
        if (from->pDeviceRenderAreas)
        {
            to->pDeviceRenderAreas = (VkRect2D*)pool->alloc(from->deviceRenderAreaCount * sizeof(const VkRect2D));
            to->deviceRenderAreaCount = from->deviceRenderAreaCount;
            for (uint32_t i = 0; i < (uint32_t)from->deviceRenderAreaCount; ++i)
            {
                deepcopy_VkRect2D(pool, from->pDeviceRenderAreas + i, (VkRect2D*)(to->pDeviceRenderAreas + i));
            }
        }
    }
}

void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
    BumpPool* pool,
    const VkDeviceGroupCommandBufferBeginInfo* from,
    VkDeviceGroupCommandBufferBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceGroupSubmitInfo(
    BumpPool* pool,
    const VkDeviceGroupSubmitInfo* from,
    VkDeviceGroupSubmitInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphoreDeviceIndices = nullptr;
    if (from->pWaitSemaphoreDeviceIndices)
    {
        to->pWaitSemaphoreDeviceIndices = (uint32_t*)pool->dupArray(from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
    }
    to->pCommandBufferDeviceMasks = nullptr;
    if (from->pCommandBufferDeviceMasks)
    {
        to->pCommandBufferDeviceMasks = (uint32_t*)pool->dupArray(from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
    }
    to->pSignalSemaphoreDeviceIndices = nullptr;
    if (from->pSignalSemaphoreDeviceIndices)
    {
        to->pSignalSemaphoreDeviceIndices = (uint32_t*)pool->dupArray(from->pSignalSemaphoreDeviceIndices, from->signalSemaphoreCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkDeviceGroupBindSparseInfo(
    BumpPool* pool,
    const VkDeviceGroupBindSparseInfo* from,
    VkDeviceGroupBindSparseInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
    BumpPool* pool,
    const VkBindBufferMemoryDeviceGroupInfo* from,
    VkBindBufferMemoryDeviceGroupInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDeviceIndices = nullptr;
    if (from->pDeviceIndices)
    {
        to->pDeviceIndices = (uint32_t*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkBindImageMemoryDeviceGroupInfo(
    BumpPool* pool,
    const VkBindImageMemoryDeviceGroupInfo* from,
    VkBindImageMemoryDeviceGroupInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDeviceIndices = nullptr;
    if (from->pDeviceIndices)
    {
        to->pDeviceIndices = (uint32_t*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
    }
    if (from)
    {
        to->pSplitInstanceBindRegions = nullptr;
        if (from->pSplitInstanceBindRegions)
        {
            to->pSplitInstanceBindRegions = (VkRect2D*)pool->alloc(from->splitInstanceBindRegionCount * sizeof(const VkRect2D));
            to->splitInstanceBindRegionCount = from->splitInstanceBindRegionCount;
            for (uint32_t i = 0; i < (uint32_t)from->splitInstanceBindRegionCount; ++i)
            {
                deepcopy_VkRect2D(pool, from->pSplitInstanceBindRegions + i, (VkRect2D*)(to->pSplitInstanceBindRegions + i));
            }
        }
    }
}

void deepcopy_VkPhysicalDeviceGroupProperties(
    BumpPool* pool,
    const VkPhysicalDeviceGroupProperties* from,
    VkPhysicalDeviceGroupProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->physicalDevices, from->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
}

void deepcopy_VkDeviceGroupDeviceCreateInfo(
    BumpPool* pool,
    const VkDeviceGroupDeviceCreateInfo* from,
    VkDeviceGroupDeviceCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pPhysicalDevices = nullptr;
    if (from->pPhysicalDevices)
    {
        to->pPhysicalDevices = (VkPhysicalDevice*)pool->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
    }
}

void deepcopy_VkBufferMemoryRequirementsInfo2(
    BumpPool* pool,
    const VkBufferMemoryRequirementsInfo2* from,
    VkBufferMemoryRequirementsInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImageMemoryRequirementsInfo2(
    BumpPool* pool,
    const VkImageMemoryRequirementsInfo2* from,
    VkImageMemoryRequirementsInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImageSparseMemoryRequirementsInfo2(
    BumpPool* pool,
    const VkImageSparseMemoryRequirementsInfo2* from,
    VkImageSparseMemoryRequirementsInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryRequirements2(
    BumpPool* pool,
    const VkMemoryRequirements2* from,
    VkMemoryRequirements2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkMemoryRequirements(pool, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
}

void deepcopy_VkSparseImageMemoryRequirements2(
    BumpPool* pool,
    const VkSparseImageMemoryRequirements2* from,
    VkSparseImageMemoryRequirements2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkSparseImageMemoryRequirements(pool, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
}

void deepcopy_VkPhysicalDeviceFeatures2(
    BumpPool* pool,
    const VkPhysicalDeviceFeatures2* from,
    VkPhysicalDeviceFeatures2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkPhysicalDeviceFeatures(pool, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
}

void deepcopy_VkPhysicalDeviceProperties2(
    BumpPool* pool,
    const VkPhysicalDeviceProperties2* from,
    VkPhysicalDeviceProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkPhysicalDeviceProperties(pool, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
}

void deepcopy_VkFormatProperties2(
    BumpPool* pool,
    const VkFormatProperties2* from,
    VkFormatProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkFormatProperties(pool, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
}

void deepcopy_VkImageFormatProperties2(
    BumpPool* pool,
    const VkImageFormatProperties2* from,
    VkImageFormatProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
}

void deepcopy_VkPhysicalDeviceImageFormatInfo2(
    BumpPool* pool,
    const VkPhysicalDeviceImageFormatInfo2* from,
    VkPhysicalDeviceImageFormatInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkQueueFamilyProperties2(
    BumpPool* pool,
    const VkQueueFamilyProperties2* from,
    VkQueueFamilyProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkQueueFamilyProperties(pool, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
}

void deepcopy_VkPhysicalDeviceMemoryProperties2(
    BumpPool* pool,
    const VkPhysicalDeviceMemoryProperties2* from,
    VkPhysicalDeviceMemoryProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkPhysicalDeviceMemoryProperties(pool, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
}

void deepcopy_VkSparseImageFormatProperties2(
    BumpPool* pool,
    const VkSparseImageFormatProperties2* from,
    VkSparseImageFormatProperties2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkSparseImageFormatProperties(pool, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
}

void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
    BumpPool* pool,
    const VkPhysicalDeviceSparseImageFormatInfo2* from,
    VkPhysicalDeviceSparseImageFormatInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDevicePointClippingProperties(
    BumpPool* pool,
    const VkPhysicalDevicePointClippingProperties* from,
    VkPhysicalDevicePointClippingProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkInputAttachmentAspectReference(
    BumpPool* pool,
    const VkInputAttachmentAspectReference* from,
    VkInputAttachmentAspectReference* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
    BumpPool* pool,
    const VkRenderPassInputAttachmentAspectCreateInfo* from,
    VkRenderPassInputAttachmentAspectCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAspectReferences = nullptr;
        if (from->pAspectReferences)
        {
            to->pAspectReferences = (VkInputAttachmentAspectReference*)pool->alloc(from->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
            to->aspectReferenceCount = from->aspectReferenceCount;
            for (uint32_t i = 0; i < (uint32_t)from->aspectReferenceCount; ++i)
            {
                deepcopy_VkInputAttachmentAspectReference(pool, from->pAspectReferences + i, (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
            }
        }
    }
}

void deepcopy_VkImageViewUsageCreateInfo(
    BumpPool* pool,
    const VkImageViewUsageCreateInfo* from,
    VkImageViewUsageCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
    BumpPool* pool,
    const VkPipelineTessellationDomainOriginStateCreateInfo* from,
    VkPipelineTessellationDomainOriginStateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkRenderPassMultiviewCreateInfo(
    BumpPool* pool,
    const VkRenderPassMultiviewCreateInfo* from,
    VkRenderPassMultiviewCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pViewMasks = nullptr;
    if (from->pViewMasks)
    {
        to->pViewMasks = (uint32_t*)pool->dupArray(from->pViewMasks, from->subpassCount * sizeof(const uint32_t));
    }
    to->pViewOffsets = nullptr;
    if (from->pViewOffsets)
    {
        to->pViewOffsets = (int32_t*)pool->dupArray(from->pViewOffsets, from->dependencyCount * sizeof(const int32_t));
    }
    to->pCorrelationMasks = nullptr;
    if (from->pCorrelationMasks)
    {
        to->pCorrelationMasks = (uint32_t*)pool->dupArray(from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkPhysicalDeviceMultiviewFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceMultiviewFeatures* from,
    VkPhysicalDeviceMultiviewFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceMultiviewProperties(
    BumpPool* pool,
    const VkPhysicalDeviceMultiviewProperties* from,
    VkPhysicalDeviceMultiviewProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceVariablePointersFeatures* from,
    VkPhysicalDeviceVariablePointersFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceProtectedMemoryFeatures* from,
    VkPhysicalDeviceProtectedMemoryFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
    BumpPool* pool,
    const VkPhysicalDeviceProtectedMemoryProperties* from,
    VkPhysicalDeviceProtectedMemoryProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceQueueInfo2(
    BumpPool* pool,
    const VkDeviceQueueInfo2* from,
    VkDeviceQueueInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkProtectedSubmitInfo(
    BumpPool* pool,
    const VkProtectedSubmitInfo* from,
    VkProtectedSubmitInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSamplerYcbcrConversionCreateInfo(
    BumpPool* pool,
    const VkSamplerYcbcrConversionCreateInfo* from,
    VkSamplerYcbcrConversionCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
}

void deepcopy_VkSamplerYcbcrConversionInfo(
    BumpPool* pool,
    const VkSamplerYcbcrConversionInfo* from,
    VkSamplerYcbcrConversionInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBindImagePlaneMemoryInfo(
    BumpPool* pool,
    const VkBindImagePlaneMemoryInfo* from,
    VkBindImagePlaneMemoryInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImagePlaneMemoryRequirementsInfo(
    BumpPool* pool,
    const VkImagePlaneMemoryRequirementsInfo* from,
    VkImagePlaneMemoryRequirementsInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
    VkPhysicalDeviceSamplerYcbcrConversionFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
    BumpPool* pool,
    const VkSamplerYcbcrConversionImageFormatProperties* from,
    VkSamplerYcbcrConversionImageFormatProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDescriptorUpdateTemplateEntry(
    BumpPool* pool,
    const VkDescriptorUpdateTemplateEntry* from,
    VkDescriptorUpdateTemplateEntry* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
    BumpPool* pool,
    const VkDescriptorUpdateTemplateCreateInfo* from,
    VkDescriptorUpdateTemplateCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pDescriptorUpdateEntries = nullptr;
        if (from->pDescriptorUpdateEntries)
        {
            to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)pool->alloc(from->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
            to->descriptorUpdateEntryCount = from->descriptorUpdateEntryCount;
            for (uint32_t i = 0; i < (uint32_t)from->descriptorUpdateEntryCount; ++i)
            {
                deepcopy_VkDescriptorUpdateTemplateEntry(pool, from->pDescriptorUpdateEntries + i, (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
            }
        }
    }
}

void deepcopy_VkExternalMemoryProperties(
    BumpPool* pool,
    const VkExternalMemoryProperties* from,
    VkExternalMemoryProperties* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
    BumpPool* pool,
    const VkPhysicalDeviceExternalImageFormatInfo* from,
    VkPhysicalDeviceExternalImageFormatInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalImageFormatProperties(
    BumpPool* pool,
    const VkExternalImageFormatProperties* from,
    VkExternalImageFormatProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}

void deepcopy_VkPhysicalDeviceExternalBufferInfo(
    BumpPool* pool,
    const VkPhysicalDeviceExternalBufferInfo* from,
    VkPhysicalDeviceExternalBufferInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalBufferProperties(
    BumpPool* pool,
    const VkExternalBufferProperties* from,
    VkExternalBufferProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}

void deepcopy_VkPhysicalDeviceIDProperties(
    BumpPool* pool,
    const VkPhysicalDeviceIDProperties* from,
    VkPhysicalDeviceIDProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->deviceUUID, from->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    memcpy(to->driverUUID, from->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
}

void deepcopy_VkExternalMemoryImageCreateInfo(
    BumpPool* pool,
    const VkExternalMemoryImageCreateInfo* from,
    VkExternalMemoryImageCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalMemoryBufferCreateInfo(
    BumpPool* pool,
    const VkExternalMemoryBufferCreateInfo* from,
    VkExternalMemoryBufferCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportMemoryAllocateInfo(
    BumpPool* pool,
    const VkExportMemoryAllocateInfo* from,
    VkExportMemoryAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceExternalFenceInfo(
    BumpPool* pool,
    const VkPhysicalDeviceExternalFenceInfo* from,
    VkPhysicalDeviceExternalFenceInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalFenceProperties(
    BumpPool* pool,
    const VkExternalFenceProperties* from,
    VkExternalFenceProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportFenceCreateInfo(
    BumpPool* pool,
    const VkExportFenceCreateInfo* from,
    VkExportFenceCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportSemaphoreCreateInfo(
    BumpPool* pool,
    const VkExportSemaphoreCreateInfo* from,
    VkExportSemaphoreCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
    BumpPool* pool,
    const VkPhysicalDeviceExternalSemaphoreInfo* from,
    VkPhysicalDeviceExternalSemaphoreInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalSemaphoreProperties(
    BumpPool* pool,
    const VkExternalSemaphoreProperties* from,
    VkExternalSemaphoreProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceMaintenance3Properties(
    BumpPool* pool,
    const VkPhysicalDeviceMaintenance3Properties* from,
    VkPhysicalDeviceMaintenance3Properties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDescriptorSetLayoutSupport(
    BumpPool* pool,
    const VkDescriptorSetLayoutSupport* from,
    VkDescriptorSetLayoutSupport* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceShaderDrawParametersFeatures* from,
    VkPhysicalDeviceShaderDrawParametersFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_VERSION_1_2
void deepcopy_VkPhysicalDeviceVulkan11Features(
    BumpPool* pool,
    const VkPhysicalDeviceVulkan11Features* from,
    VkPhysicalDeviceVulkan11Features* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceVulkan11Properties(
    BumpPool* pool,
    const VkPhysicalDeviceVulkan11Properties* from,
    VkPhysicalDeviceVulkan11Properties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->deviceUUID, from->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    memcpy(to->driverUUID, from->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
}

void deepcopy_VkPhysicalDeviceVulkan12Features(
    BumpPool* pool,
    const VkPhysicalDeviceVulkan12Features* from,
    VkPhysicalDeviceVulkan12Features* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkConformanceVersion(
    BumpPool* pool,
    const VkConformanceVersion* from,
    VkConformanceVersion* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPhysicalDeviceVulkan12Properties(
    BumpPool* pool,
    const VkPhysicalDeviceVulkan12Properties* from,
    VkPhysicalDeviceVulkan12Properties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->driverName, from->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    memcpy(to->driverInfo, from->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    deepcopy_VkConformanceVersion(pool, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
}

void deepcopy_VkImageFormatListCreateInfo(
    BumpPool* pool,
    const VkImageFormatListCreateInfo* from,
    VkImageFormatListCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pViewFormats = nullptr;
    if (from->pViewFormats)
    {
        to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
    }
}

void deepcopy_VkAttachmentDescription2(
    BumpPool* pool,
    const VkAttachmentDescription2* from,
    VkAttachmentDescription2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAttachmentReference2(
    BumpPool* pool,
    const VkAttachmentReference2* from,
    VkAttachmentReference2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSubpassDescription2(
    BumpPool* pool,
    const VkSubpassDescription2* from,
    VkSubpassDescription2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pInputAttachments = nullptr;
        if (from->pInputAttachments)
        {
            to->pInputAttachments = (VkAttachmentReference2*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference2));
            to->inputAttachmentCount = from->inputAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference2(pool, from->pInputAttachments + i, (VkAttachmentReference2*)(to->pInputAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pColorAttachments = nullptr;
        if (from->pColorAttachments)
        {
            to->pColorAttachments = (VkAttachmentReference2*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
            to->colorAttachmentCount = from->colorAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference2(pool, from->pColorAttachments + i, (VkAttachmentReference2*)(to->pColorAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pResolveAttachments = nullptr;
        if (from->pResolveAttachments)
        {
            to->pResolveAttachments = (VkAttachmentReference2*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
            to->colorAttachmentCount = from->colorAttachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
            {
                deepcopy_VkAttachmentReference2(pool, from->pResolveAttachments + i, (VkAttachmentReference2*)(to->pResolveAttachments + i));
            }
        }
    }
    to->pDepthStencilAttachment = nullptr;
    if (from->pDepthStencilAttachment)
    {
        to->pDepthStencilAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
        deepcopy_VkAttachmentReference2(pool, from->pDepthStencilAttachment, (VkAttachmentReference2*)(to->pDepthStencilAttachment));
    }
    to->pPreserveAttachments = nullptr;
    if (from->pPreserveAttachments)
    {
        to->pPreserveAttachments = (uint32_t*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkSubpassDependency2(
    BumpPool* pool,
    const VkSubpassDependency2* from,
    VkSubpassDependency2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkRenderPassCreateInfo2(
    BumpPool* pool,
    const VkRenderPassCreateInfo2* from,
    VkRenderPassCreateInfo2* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAttachments = nullptr;
        if (from->pAttachments)
        {
            to->pAttachments = (VkAttachmentDescription2*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription2));
            to->attachmentCount = from->attachmentCount;
            for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
            {
                deepcopy_VkAttachmentDescription2(pool, from->pAttachments + i, (VkAttachmentDescription2*)(to->pAttachments + i));
            }
        }
    }
    if (from)
    {
        to->pSubpasses = nullptr;
        if (from->pSubpasses)
        {
            to->pSubpasses = (VkSubpassDescription2*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription2));
            to->subpassCount = from->subpassCount;
            for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
            {
                deepcopy_VkSubpassDescription2(pool, from->pSubpasses + i, (VkSubpassDescription2*)(to->pSubpasses + i));
            }
        }
    }
    if (from)
    {
        to->pDependencies = nullptr;
        if (from->pDependencies)
        {
            to->pDependencies = (VkSubpassDependency2*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency2));
            to->dependencyCount = from->dependencyCount;
            for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
            {
                deepcopy_VkSubpassDependency2(pool, from->pDependencies + i, (VkSubpassDependency2*)(to->pDependencies + i));
            }
        }
    }
    to->pCorrelatedViewMasks = nullptr;
    if (from->pCorrelatedViewMasks)
    {
        to->pCorrelatedViewMasks = (uint32_t*)pool->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkSubpassBeginInfo(
    BumpPool* pool,
    const VkSubpassBeginInfo* from,
    VkSubpassBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSubpassEndInfo(
    BumpPool* pool,
    const VkSubpassEndInfo* from,
    VkSubpassEndInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDevice8BitStorageFeatures(
    BumpPool* pool,
    const VkPhysicalDevice8BitStorageFeatures* from,
    VkPhysicalDevice8BitStorageFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceDriverProperties(
    BumpPool* pool,
    const VkPhysicalDeviceDriverProperties* from,
    VkPhysicalDeviceDriverProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->driverName, from->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    memcpy(to->driverInfo, from->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    deepcopy_VkConformanceVersion(pool, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
}

void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
    BumpPool* pool,
    const VkPhysicalDeviceShaderAtomicInt64Features* from,
    VkPhysicalDeviceShaderAtomicInt64Features* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
    BumpPool* pool,
    const VkPhysicalDeviceShaderFloat16Int8Features* from,
    VkPhysicalDeviceShaderFloat16Int8Features* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceFloatControlsProperties(
    BumpPool* pool,
    const VkPhysicalDeviceFloatControlsProperties* from,
    VkPhysicalDeviceFloatControlsProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    BumpPool* pool,
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
    VkDescriptorSetLayoutBindingFlagsCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pBindingFlags = nullptr;
    if (from->pBindingFlags)
    {
        to->pBindingFlags = (VkDescriptorBindingFlags*)pool->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlags));
    }
}

void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceDescriptorIndexingFeatures* from,
    VkPhysicalDeviceDescriptorIndexingFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
    BumpPool* pool,
    const VkPhysicalDeviceDescriptorIndexingProperties* from,
    VkPhysicalDeviceDescriptorIndexingProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    BumpPool* pool,
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
    VkDescriptorSetVariableDescriptorCountAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDescriptorCounts = nullptr;
    if (from->pDescriptorCounts)
    {
        to->pDescriptorCounts = (uint32_t*)pool->dupArray(from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    BumpPool* pool,
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
    VkDescriptorSetVariableDescriptorCountLayoutSupport* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSubpassDescriptionDepthStencilResolve(
    BumpPool* pool,
    const VkSubpassDescriptionDepthStencilResolve* from,
    VkSubpassDescriptionDepthStencilResolve* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDepthStencilResolveAttachment = nullptr;
    if (from->pDepthStencilResolveAttachment)
    {
        to->pDepthStencilResolveAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
        deepcopy_VkAttachmentReference2(pool, from->pDepthStencilResolveAttachment, (VkAttachmentReference2*)(to->pDepthStencilResolveAttachment));
    }
}

void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
    BumpPool* pool,
    const VkPhysicalDeviceDepthStencilResolveProperties* from,
    VkPhysicalDeviceDepthStencilResolveProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
    VkPhysicalDeviceScalarBlockLayoutFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImageStencilUsageCreateInfo(
    BumpPool* pool,
    const VkImageStencilUsageCreateInfo* from,
    VkImageStencilUsageCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSamplerReductionModeCreateInfo(
    BumpPool* pool,
    const VkSamplerReductionModeCreateInfo* from,
    VkSamplerReductionModeCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    BumpPool* pool,
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
    VkPhysicalDeviceSamplerFilterMinmaxProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
    VkPhysicalDeviceVulkanMemoryModelFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceImagelessFramebufferFeatures* from,
    VkPhysicalDeviceImagelessFramebufferFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkFramebufferAttachmentImageInfo(
    BumpPool* pool,
    const VkFramebufferAttachmentImageInfo* from,
    VkFramebufferAttachmentImageInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pViewFormats = nullptr;
    if (from->pViewFormats)
    {
        to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
    }
}

void deepcopy_VkFramebufferAttachmentsCreateInfo(
    BumpPool* pool,
    const VkFramebufferAttachmentsCreateInfo* from,
    VkFramebufferAttachmentsCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAttachmentImageInfos = nullptr;
        if (from->pAttachmentImageInfos)
        {
            to->pAttachmentImageInfos = (VkFramebufferAttachmentImageInfo*)pool->alloc(from->attachmentImageInfoCount * sizeof(const VkFramebufferAttachmentImageInfo));
            to->attachmentImageInfoCount = from->attachmentImageInfoCount;
            for (uint32_t i = 0; i < (uint32_t)from->attachmentImageInfoCount; ++i)
            {
                deepcopy_VkFramebufferAttachmentImageInfo(pool, from->pAttachmentImageInfos + i, (VkFramebufferAttachmentImageInfo*)(to->pAttachmentImageInfos + i));
            }
        }
    }
}

void deepcopy_VkRenderPassAttachmentBeginInfo(
    BumpPool* pool,
    const VkRenderPassAttachmentBeginInfo* from,
    VkRenderPassAttachmentBeginInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttachments = nullptr;
    if (from->pAttachments)
    {
        to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
    }
}

void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
    VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAttachmentReferenceStencilLayout(
    BumpPool* pool,
    const VkAttachmentReferenceStencilLayout* from,
    VkAttachmentReferenceStencilLayout* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAttachmentDescriptionStencilLayout(
    BumpPool* pool,
    const VkAttachmentDescriptionStencilLayout* from,
    VkAttachmentDescriptionStencilLayout* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceHostQueryResetFeatures* from,
    VkPhysicalDeviceHostQueryResetFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
    VkPhysicalDeviceTimelineSemaphoreFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
    BumpPool* pool,
    const VkPhysicalDeviceTimelineSemaphoreProperties* from,
    VkPhysicalDeviceTimelineSemaphoreProperties* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSemaphoreTypeCreateInfo(
    BumpPool* pool,
    const VkSemaphoreTypeCreateInfo* from,
    VkSemaphoreTypeCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkTimelineSemaphoreSubmitInfo(
    BumpPool* pool,
    const VkTimelineSemaphoreSubmitInfo* from,
    VkTimelineSemaphoreSubmitInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphoreValues = nullptr;
    if (from->pWaitSemaphoreValues)
    {
        to->pWaitSemaphoreValues = (uint64_t*)pool->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValueCount * sizeof(const uint64_t));
    }
    to->pSignalSemaphoreValues = nullptr;
    if (from->pSignalSemaphoreValues)
    {
        to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValueCount * sizeof(const uint64_t));
    }
}

void deepcopy_VkSemaphoreWaitInfo(
    BumpPool* pool,
    const VkSemaphoreWaitInfo* from,
    VkSemaphoreWaitInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pSemaphores = nullptr;
    if (from->pSemaphores)
    {
        to->pSemaphores = (VkSemaphore*)pool->dupArray(from->pSemaphores, from->semaphoreCount * sizeof(const VkSemaphore));
    }
    to->pValues = nullptr;
    if (from->pValues)
    {
        to->pValues = (uint64_t*)pool->dupArray(from->pValues, from->semaphoreCount * sizeof(const uint64_t));
    }
}

void deepcopy_VkSemaphoreSignalInfo(
    BumpPool* pool,
    const VkSemaphoreSignalInfo* from,
    VkSemaphoreSignalInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
    BumpPool* pool,
    const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
    VkPhysicalDeviceBufferDeviceAddressFeatures* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBufferDeviceAddressInfo(
    BumpPool* pool,
    const VkBufferDeviceAddressInfo* from,
    VkBufferDeviceAddressInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
    BumpPool* pool,
    const VkBufferOpaqueCaptureAddressCreateInfo* from,
    VkBufferOpaqueCaptureAddressCreateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
    BumpPool* pool,
    const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
    VkMemoryOpaqueCaptureAddressAllocateInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
    BumpPool* pool,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
    VkDeviceMemoryOpaqueCaptureAddressInfo* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_surface
void deepcopy_VkSurfaceCapabilitiesKHR(
    BumpPool* pool,
    const VkSurfaceCapabilitiesKHR* from,
    VkSurfaceCapabilitiesKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
    deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
    deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
}

void deepcopy_VkSurfaceFormatKHR(
    BumpPool* pool,
    const VkSurfaceFormatKHR* from,
    VkSurfaceFormatKHR* to)
{
    (void)pool;
    *to = *from;
}

#endif
#ifdef VK_KHR_swapchain
void deepcopy_VkSwapchainCreateInfoKHR(
    BumpPool* pool,
    const VkSwapchainCreateInfoKHR* from,
    VkSwapchainCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
    to->pQueueFamilyIndices = nullptr;
    if (from->pQueueFamilyIndices)
    {
        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkPresentInfoKHR(
    BumpPool* pool,
    const VkPresentInfoKHR* from,
    VkPresentInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphores = nullptr;
    if (from->pWaitSemaphores)
    {
        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
    }
    to->pSwapchains = nullptr;
    if (from->pSwapchains)
    {
        to->pSwapchains = (VkSwapchainKHR*)pool->dupArray(from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
    }
    to->pImageIndices = nullptr;
    if (from->pImageIndices)
    {
        to->pImageIndices = (uint32_t*)pool->dupArray(from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
    }
    to->pResults = nullptr;
    if (from->pResults)
    {
        to->pResults = (VkResult*)pool->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
    }
}

void deepcopy_VkImageSwapchainCreateInfoKHR(
    BumpPool* pool,
    const VkImageSwapchainCreateInfoKHR* from,
    VkImageSwapchainCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBindImageMemorySwapchainInfoKHR(
    BumpPool* pool,
    const VkBindImageMemorySwapchainInfoKHR* from,
    VkBindImageMemorySwapchainInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAcquireNextImageInfoKHR(
    BumpPool* pool,
    const VkAcquireNextImageInfoKHR* from,
    VkAcquireNextImageInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
    BumpPool* pool,
    const VkDeviceGroupPresentCapabilitiesKHR* from,
    VkDeviceGroupPresentCapabilitiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->presentMask, from->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
}

void deepcopy_VkDeviceGroupPresentInfoKHR(
    BumpPool* pool,
    const VkDeviceGroupPresentInfoKHR* from,
    VkDeviceGroupPresentInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDeviceMasks = nullptr;
    if (from->pDeviceMasks)
    {
        to->pDeviceMasks = (uint32_t*)pool->dupArray(from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
    BumpPool* pool,
    const VkDeviceGroupSwapchainCreateInfoKHR* from,
    VkDeviceGroupSwapchainCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_display
void deepcopy_VkDisplayModeParametersKHR(
    BumpPool* pool,
    const VkDisplayModeParametersKHR* from,
    VkDisplayModeParametersKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkExtent2D(pool, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
}

void deepcopy_VkDisplayModeCreateInfoKHR(
    BumpPool* pool,
    const VkDisplayModeCreateInfoKHR* from,
    VkDisplayModeCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
}

void deepcopy_VkDisplayModePropertiesKHR(
    BumpPool* pool,
    const VkDisplayModePropertiesKHR* from,
    VkDisplayModePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
}

void deepcopy_VkDisplayPlaneCapabilitiesKHR(
    BumpPool* pool,
    const VkDisplayPlaneCapabilitiesKHR* from,
    VkDisplayPlaneCapabilitiesKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkOffset2D(pool, &from->minSrcPosition, (VkOffset2D*)(&to->minSrcPosition));
    deepcopy_VkOffset2D(pool, &from->maxSrcPosition, (VkOffset2D*)(&to->maxSrcPosition));
    deepcopy_VkExtent2D(pool, &from->minSrcExtent, (VkExtent2D*)(&to->minSrcExtent));
    deepcopy_VkExtent2D(pool, &from->maxSrcExtent, (VkExtent2D*)(&to->maxSrcExtent));
    deepcopy_VkOffset2D(pool, &from->minDstPosition, (VkOffset2D*)(&to->minDstPosition));
    deepcopy_VkOffset2D(pool, &from->maxDstPosition, (VkOffset2D*)(&to->maxDstPosition));
    deepcopy_VkExtent2D(pool, &from->minDstExtent, (VkExtent2D*)(&to->minDstExtent));
    deepcopy_VkExtent2D(pool, &from->maxDstExtent, (VkExtent2D*)(&to->maxDstExtent));
}

void deepcopy_VkDisplayPlanePropertiesKHR(
    BumpPool* pool,
    const VkDisplayPlanePropertiesKHR* from,
    VkDisplayPlanePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDisplayPropertiesKHR(
    BumpPool* pool,
    const VkDisplayPropertiesKHR* from,
    VkDisplayPropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    to->displayName = nullptr;
    if (from->displayName)
    {
        to->displayName = pool->strDup(from->displayName);
    }
    deepcopy_VkExtent2D(pool, &from->physicalDimensions, (VkExtent2D*)(&to->physicalDimensions));
    deepcopy_VkExtent2D(pool, &from->physicalResolution, (VkExtent2D*)(&to->physicalResolution));
}

void deepcopy_VkDisplaySurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkDisplaySurfaceCreateInfoKHR* from,
    VkDisplaySurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
}

#endif
#ifdef VK_KHR_display_swapchain
void deepcopy_VkDisplayPresentInfoKHR(
    BumpPool* pool,
    const VkDisplayPresentInfoKHR* from,
    VkDisplayPresentInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkRect2D(pool, &from->srcRect, (VkRect2D*)(&to->srcRect));
    deepcopy_VkRect2D(pool, &from->dstRect, (VkRect2D*)(&to->dstRect));
}

#endif
#ifdef VK_KHR_xlib_surface
void deepcopy_VkXlibSurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkXlibSurfaceCreateInfoKHR* from,
    VkXlibSurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->dpy = nullptr;
    if (from->dpy)
    {
        to->dpy = (Display*)pool->dupArray(from->dpy, sizeof(Display));
    }
}

#endif
#ifdef VK_KHR_xcb_surface
void deepcopy_VkXcbSurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkXcbSurfaceCreateInfoKHR* from,
    VkXcbSurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->connection = nullptr;
    if (from->connection)
    {
        to->connection = (xcb_connection_t*)pool->dupArray(from->connection, sizeof(xcb_connection_t));
    }
}

#endif
#ifdef VK_KHR_wayland_surface
void deepcopy_VkWaylandSurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkWaylandSurfaceCreateInfoKHR* from,
    VkWaylandSurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->display = nullptr;
    if (from->display)
    {
        to->display = (wl_display*)pool->dupArray(from->display, sizeof(wl_display));
    }
    to->surface = nullptr;
    if (from->surface)
    {
        to->surface = (wl_surface*)pool->dupArray(from->surface, sizeof(wl_surface));
    }
}

#endif
#ifdef VK_KHR_android_surface
void deepcopy_VkAndroidSurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkAndroidSurfaceCreateInfoKHR* from,
    VkAndroidSurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->window = nullptr;
    if (from->window)
    {
        to->window = (ANativeWindow*)pool->dupArray(from->window, sizeof(ANativeWindow));
    }
}

#endif
#ifdef VK_KHR_win32_surface
void deepcopy_VkWin32SurfaceCreateInfoKHR(
    BumpPool* pool,
    const VkWin32SurfaceCreateInfoKHR* from,
    VkWin32SurfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
#endif
#ifdef VK_KHR_device_group
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
#endif
#ifdef VK_KHR_external_memory_capabilities
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoKHR(
    BumpPool* pool,
    const VkImportMemoryWin32HandleInfoKHR* from,
    VkImportMemoryWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportMemoryWin32HandleInfoKHR(
    BumpPool* pool,
    const VkExportMemoryWin32HandleInfoKHR* from,
    VkExportMemoryWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttributes = nullptr;
    if (from->pAttributes)
    {
        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
    }
}

void deepcopy_VkMemoryWin32HandlePropertiesKHR(
    BumpPool* pool,
    const VkMemoryWin32HandlePropertiesKHR* from,
    VkMemoryWin32HandlePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryGetWin32HandleInfoKHR(
    BumpPool* pool,
    const VkMemoryGetWin32HandleInfoKHR* from,
    VkMemoryGetWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_external_memory_fd
void deepcopy_VkImportMemoryFdInfoKHR(
    BumpPool* pool,
    const VkImportMemoryFdInfoKHR* from,
    VkImportMemoryFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryFdPropertiesKHR(
    BumpPool* pool,
    const VkMemoryFdPropertiesKHR* from,
    VkMemoryFdPropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryGetFdInfoKHR(
    BumpPool* pool,
    const VkMemoryGetFdInfoKHR* from,
    VkMemoryGetFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    BumpPool* pool,
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
    VkWin32KeyedMutexAcquireReleaseInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAcquireSyncs = nullptr;
    if (from->pAcquireSyncs)
    {
        to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
    }
    to->pAcquireKeys = nullptr;
    if (from->pAcquireKeys)
    {
        to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
    }
    to->pAcquireTimeouts = nullptr;
    if (from->pAcquireTimeouts)
    {
        to->pAcquireTimeouts = (uint32_t*)pool->dupArray(from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
    }
    to->pReleaseSyncs = nullptr;
    if (from->pReleaseSyncs)
    {
        to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
    }
    to->pReleaseKeys = nullptr;
    if (from->pReleaseKeys)
    {
        to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
    }
}

#endif
#ifdef VK_KHR_external_semaphore_capabilities
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
    BumpPool* pool,
    const VkImportSemaphoreWin32HandleInfoKHR* from,
    VkImportSemaphoreWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
    BumpPool* pool,
    const VkExportSemaphoreWin32HandleInfoKHR* from,
    VkExportSemaphoreWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttributes = nullptr;
    if (from->pAttributes)
    {
        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
    }
}

void deepcopy_VkD3D12FenceSubmitInfoKHR(
    BumpPool* pool,
    const VkD3D12FenceSubmitInfoKHR* from,
    VkD3D12FenceSubmitInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pWaitSemaphoreValues = nullptr;
    if (from->pWaitSemaphoreValues)
    {
        to->pWaitSemaphoreValues = (uint64_t*)pool->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
    }
    to->pSignalSemaphoreValues = nullptr;
    if (from->pSignalSemaphoreValues)
    {
        to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
    }
}

void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
    BumpPool* pool,
    const VkSemaphoreGetWin32HandleInfoKHR* from,
    VkSemaphoreGetWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_external_semaphore_fd
void deepcopy_VkImportSemaphoreFdInfoKHR(
    BumpPool* pool,
    const VkImportSemaphoreFdInfoKHR* from,
    VkImportSemaphoreFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSemaphoreGetFdInfoKHR(
    BumpPool* pool,
    const VkSemaphoreGetFdInfoKHR* from,
    VkSemaphoreGetFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
    VkPhysicalDevicePushDescriptorPropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_shader_float16_int8
#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
void deepcopy_VkRectLayerKHR(
    BumpPool* pool,
    const VkRectLayerKHR* from,
    VkRectLayerKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
    deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
}

void deepcopy_VkPresentRegionKHR(
    BumpPool* pool,
    const VkPresentRegionKHR* from,
    VkPresentRegionKHR* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pRectangles = nullptr;
        if (from->pRectangles)
        {
            to->pRectangles = (VkRectLayerKHR*)pool->alloc(from->rectangleCount * sizeof(const VkRectLayerKHR));
            to->rectangleCount = from->rectangleCount;
            for (uint32_t i = 0; i < (uint32_t)from->rectangleCount; ++i)
            {
                deepcopy_VkRectLayerKHR(pool, from->pRectangles + i, (VkRectLayerKHR*)(to->pRectangles + i));
            }
        }
    }
}

void deepcopy_VkPresentRegionsKHR(
    BumpPool* pool,
    const VkPresentRegionsKHR* from,
    VkPresentRegionsKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkPresentRegionKHR*)pool->alloc(from->swapchainCount * sizeof(const VkPresentRegionKHR));
            to->swapchainCount = from->swapchainCount;
            for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
            {
                deepcopy_VkPresentRegionKHR(pool, from->pRegions + i, (VkPresentRegionKHR*)(to->pRegions + i));
            }
        }
    }
}

#endif
#ifdef VK_KHR_descriptor_update_template
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
    BumpPool* pool,
    const VkSharedPresentSurfaceCapabilitiesKHR* from,
    VkSharedPresentSurfaceCapabilitiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_external_fence_capabilities
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
void deepcopy_VkImportFenceWin32HandleInfoKHR(
    BumpPool* pool,
    const VkImportFenceWin32HandleInfoKHR* from,
    VkImportFenceWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportFenceWin32HandleInfoKHR(
    BumpPool* pool,
    const VkExportFenceWin32HandleInfoKHR* from,
    VkExportFenceWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttributes = nullptr;
    if (from->pAttributes)
    {
        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
    }
}

void deepcopy_VkFenceGetWin32HandleInfoKHR(
    BumpPool* pool,
    const VkFenceGetWin32HandleInfoKHR* from,
    VkFenceGetWin32HandleInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_external_fence_fd
void deepcopy_VkImportFenceFdInfoKHR(
    BumpPool* pool,
    const VkImportFenceFdInfoKHR* from,
    VkImportFenceFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkFenceGetFdInfoKHR(
    BumpPool* pool,
    const VkFenceGetFdInfoKHR* from,
    VkFenceGetFdInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
    VkPhysicalDevicePerformanceQueryFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
    VkPhysicalDevicePerformanceQueryPropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceCounterKHR(
    BumpPool* pool,
    const VkPerformanceCounterKHR* from,
    VkPerformanceCounterKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->uuid, from->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}

void deepcopy_VkPerformanceCounterDescriptionKHR(
    BumpPool* pool,
    const VkPerformanceCounterDescriptionKHR* from,
    VkPerformanceCounterDescriptionKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->category, from->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
    BumpPool* pool,
    const VkQueryPoolPerformanceCreateInfoKHR* from,
    VkQueryPoolPerformanceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pCounterIndices = nullptr;
    if (from->pCounterIndices)
    {
        to->pCounterIndices = (uint32_t*)pool->dupArray(from->pCounterIndices, from->counterIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkPerformanceCounterResultKHR(
    BumpPool* pool,
    const VkPerformanceCounterResultKHR* from,
    VkPerformanceCounterResultKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkAcquireProfilingLockInfoKHR(
    BumpPool* pool,
    const VkAcquireProfilingLockInfoKHR* from,
    VkAcquireProfilingLockInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceQuerySubmitInfoKHR(
    BumpPool* pool,
    const VkPerformanceQuerySubmitInfoKHR* from,
    VkPerformanceQuerySubmitInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
    BumpPool* pool,
    const VkPhysicalDeviceSurfaceInfo2KHR* from,
    VkPhysicalDeviceSurfaceInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSurfaceCapabilities2KHR(
    BumpPool* pool,
    const VkSurfaceCapabilities2KHR* from,
    VkSurfaceCapabilities2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkSurfaceCapabilitiesKHR(pool, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
}

void deepcopy_VkSurfaceFormat2KHR(
    BumpPool* pool,
    const VkSurfaceFormat2KHR* from,
    VkSurfaceFormat2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkSurfaceFormatKHR(pool, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
}

#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
void deepcopy_VkDisplayProperties2KHR(
    BumpPool* pool,
    const VkDisplayProperties2KHR* from,
    VkDisplayProperties2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDisplayPropertiesKHR(pool, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
}

void deepcopy_VkDisplayPlaneProperties2KHR(
    BumpPool* pool,
    const VkDisplayPlaneProperties2KHR* from,
    VkDisplayPlaneProperties2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDisplayPlanePropertiesKHR(pool, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
}

void deepcopy_VkDisplayModeProperties2KHR(
    BumpPool* pool,
    const VkDisplayModeProperties2KHR* from,
    VkDisplayModeProperties2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDisplayModePropertiesKHR(pool, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
}

void deepcopy_VkDisplayPlaneInfo2KHR(
    BumpPool* pool,
    const VkDisplayPlaneInfo2KHR* from,
    VkDisplayPlaneInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDisplayPlaneCapabilities2KHR(
    BumpPool* pool,
    const VkDisplayPlaneCapabilities2KHR* from,
    VkDisplayPlaneCapabilities2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDisplayPlaneCapabilitiesKHR(pool, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
}

#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
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
#endif
#ifdef VK_KHR_bind_memory2
#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
    VkPhysicalDevicePortabilitySubsetFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
    VkPhysicalDevicePortabilitySubsetPropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_maintenance3
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
#endif
#ifdef VK_KHR_8bit_storage
#endif
#ifdef VK_KHR_shader_atomic_int64
#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceShaderClockFeaturesKHR* from,
    VkPhysicalDeviceShaderClockFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_driver_properties
#endif
#ifdef VK_KHR_shader_float_controls
#endif
#ifdef VK_KHR_depth_stencil_resolve
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
#endif
#ifdef VK_KHR_vulkan_memory_model
#endif
#ifdef VK_KHR_shader_terminate_invocation
void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
    BumpPool* pool,
    const VkFragmentShadingRateAttachmentInfoKHR* from,
    VkFragmentShadingRateAttachmentInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pFragmentShadingRateAttachment = nullptr;
    if (from->pFragmentShadingRateAttachment)
    {
        to->pFragmentShadingRateAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
        deepcopy_VkAttachmentReference2(pool, from->pFragmentShadingRateAttachment, (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
    }
    deepcopy_VkExtent2D(pool, &from->shadingRateAttachmentTexelSize, (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
}

void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    BumpPool* pool,
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
    VkPipelineFragmentShadingRateStateCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
    memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->minFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
    deepcopy_VkExtent2D(pool, &from->maxFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
    deepcopy_VkExtent2D(pool, &from->maxFragmentSize, (VkExtent2D*)(&to->maxFragmentSize));
}

void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShadingRateKHR* from,
    VkPhysicalDeviceFragmentShadingRateKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
}

#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void deepcopy_VkSurfaceProtectedCapabilitiesKHR(
    BumpPool* pool,
    const VkSurfaceProtectedCapabilitiesKHR* from,
    VkSurfaceProtectedCapabilitiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
#endif
#ifdef VK_KHR_buffer_device_address
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineInfoKHR(
    BumpPool* pool,
    const VkPipelineInfoKHR* from,
    VkPipelineInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineExecutablePropertiesKHR(
    BumpPool* pool,
    const VkPipelineExecutablePropertiesKHR* from,
    VkPipelineExecutablePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void deepcopy_VkPipelineExecutableInfoKHR(
    BumpPool* pool,
    const VkPipelineExecutableInfoKHR* from,
    VkPipelineExecutableInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineExecutableStatisticValueKHR(
    BumpPool* pool,
    const VkPipelineExecutableStatisticValueKHR* from,
    VkPipelineExecutableStatisticValueKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineExecutableStatisticKHR(
    BumpPool* pool,
    const VkPipelineExecutableStatisticKHR* from,
    VkPipelineExecutableStatisticKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    deepcopy_VkPipelineExecutableStatisticValueKHR(pool, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
}

void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
    BumpPool* pool,
    const VkPipelineExecutableInternalRepresentationKHR* from,
    VkPipelineExecutableInternalRepresentationKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    to->pData = nullptr;
    if (from->pData)
    {
        to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
    }
}

#endif
#ifdef VK_KHR_pipeline_library
void deepcopy_VkPipelineLibraryCreateInfoKHR(
    BumpPool* pool,
    const VkPipelineLibraryCreateInfoKHR* from,
    VkPipelineLibraryCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pLibraries = nullptr;
    if (from->pLibraries)
    {
        to->pLibraries = (VkPipeline*)pool->dupArray(from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
    }
}

#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_copy_commands2
void deepcopy_VkBufferCopy2KHR(
    BumpPool* pool,
    const VkBufferCopy2KHR* from,
    VkBufferCopy2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCopyBufferInfo2KHR(
    BumpPool* pool,
    const VkCopyBufferInfo2KHR* from,
    VkCopyBufferInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkBufferCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferCopy2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkBufferCopy2KHR(pool, from->pRegions + i, (VkBufferCopy2KHR*)(to->pRegions + i));
            }
        }
    }
}

void deepcopy_VkImageCopy2KHR(
    BumpPool* pool,
    const VkImageCopy2KHR* from,
    VkImageCopy2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
}

void deepcopy_VkCopyImageInfo2KHR(
    BumpPool* pool,
    const VkCopyImageInfo2KHR* from,
    VkCopyImageInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageCopy2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkImageCopy2KHR(pool, from->pRegions + i, (VkImageCopy2KHR*)(to->pRegions + i));
            }
        }
    }
}

void deepcopy_VkBufferImageCopy2KHR(
    BumpPool* pool,
    const VkBufferImageCopy2KHR* from,
    VkBufferImageCopy2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
    deepcopy_VkOffset3D(pool, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
    deepcopy_VkExtent3D(pool, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
}

void deepcopy_VkCopyBufferToImageInfo2KHR(
    BumpPool* pool,
    const VkCopyBufferToImageInfo2KHR* from,
    VkCopyBufferToImageInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkBufferImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkBufferImageCopy2KHR(pool, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
            }
        }
    }
}

void deepcopy_VkCopyImageToBufferInfo2KHR(
    BumpPool* pool,
    const VkCopyImageToBufferInfo2KHR* from,
    VkCopyImageToBufferInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkBufferImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkBufferImageCopy2KHR(pool, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
            }
        }
    }
}

void deepcopy_VkImageBlit2KHR(
    BumpPool* pool,
    const VkImageBlit2KHR* from,
    VkImageBlit2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        deepcopy_VkOffset3D(pool, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        deepcopy_VkOffset3D(pool, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
    }
}

void deepcopy_VkBlitImageInfo2KHR(
    BumpPool* pool,
    const VkBlitImageInfo2KHR* from,
    VkBlitImageInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkImageBlit2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageBlit2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkImageBlit2KHR(pool, from->pRegions + i, (VkImageBlit2KHR*)(to->pRegions + i));
            }
        }
    }
}

void deepcopy_VkImageResolve2KHR(
    BumpPool* pool,
    const VkImageResolve2KHR* from,
    VkImageResolve2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
}

void deepcopy_VkResolveImageInfo2KHR(
    BumpPool* pool,
    const VkResolveImageInfo2KHR* from,
    VkResolveImageInfo2KHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pRegions = nullptr;
        if (from->pRegions)
        {
            to->pRegions = (VkImageResolve2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageResolve2KHR));
            to->regionCount = from->regionCount;
            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
            {
                deepcopy_VkImageResolve2KHR(pool, from->pRegions + i, (VkImageResolve2KHR*)(to->pRegions + i));
            }
        }
    }
}

#endif
#ifdef VK_ANDROID_native_buffer
void deepcopy_VkNativeBufferANDROID(
    BumpPool* pool,
    const VkNativeBufferANDROID* from,
    VkNativeBufferANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->handle = nullptr;
    if (from->handle)
    {
        to->handle = (uint32_t*)pool->dupArray(from->handle, sizeof(const uint32_t));
    }
}

#endif
#ifdef VK_EXT_debug_report
void deepcopy_VkDebugReportCallbackCreateInfoEXT(
    BumpPool* pool,
    const VkDebugReportCallbackCreateInfoEXT* from,
    VkDebugReportCallbackCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pUserData = nullptr;
    if (from->pUserData)
    {
        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
    }
}

#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
void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
    BumpPool* pool,
    const VkPipelineRasterizationStateRasterizationOrderAMD* from,
    VkPipelineRasterizationStateRasterizationOrderAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void deepcopy_VkDebugMarkerObjectNameInfoEXT(
    BumpPool* pool,
    const VkDebugMarkerObjectNameInfoEXT* from,
    VkDebugMarkerObjectNameInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pObjectName = nullptr;
    if (from->pObjectName)
    {
        to->pObjectName = pool->strDup(from->pObjectName);
    }
}

void deepcopy_VkDebugMarkerObjectTagInfoEXT(
    BumpPool* pool,
    const VkDebugMarkerObjectTagInfoEXT* from,
    VkDebugMarkerObjectTagInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pTag = nullptr;
    if (from->pTag)
    {
        to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
    }
}

void deepcopy_VkDebugMarkerMarkerInfoEXT(
    BumpPool* pool,
    const VkDebugMarkerMarkerInfoEXT* from,
    VkDebugMarkerMarkerInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pMarkerName = nullptr;
    if (from->pMarkerName)
    {
        to->pMarkerName = pool->strDup(from->pMarkerName);
    }
    memcpy(to->color, from->color, 4 * sizeof(float));
}

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
    BumpPool* pool,
    const VkDedicatedAllocationImageCreateInfoNV* from,
    VkDedicatedAllocationImageCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
    BumpPool* pool,
    const VkDedicatedAllocationBufferCreateInfoNV* from,
    VkDedicatedAllocationBufferCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
    BumpPool* pool,
    const VkDedicatedAllocationMemoryAllocateInfoNV* from,
    VkDedicatedAllocationMemoryAllocateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
    VkPhysicalDeviceTransformFeedbackFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
    VkPhysicalDeviceTransformFeedbackPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
    VkPipelineRasterizationStateStreamCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NVX_image_view_handle
void deepcopy_VkImageViewHandleInfoNVX(
    BumpPool* pool,
    const VkImageViewHandleInfoNVX* from,
    VkImageViewHandleInfoNVX* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImageViewAddressPropertiesNVX(
    BumpPool* pool,
    const VkImageViewAddressPropertiesNVX* from,
    VkImageViewAddressPropertiesNVX* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_draw_indirect_count
#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
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
    BumpPool* pool,
    const VkTextureLODGatherFormatPropertiesAMD* from,
    VkTextureLODGatherFormatPropertiesAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_shader_info
void deepcopy_VkShaderResourceUsageAMD(
    BumpPool* pool,
    const VkShaderResourceUsageAMD* from,
    VkShaderResourceUsageAMD* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkShaderStatisticsInfoAMD(
    BumpPool* pool,
    const VkShaderStatisticsInfoAMD* from,
    VkShaderStatisticsInfoAMD* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkShaderResourceUsageAMD(pool, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
    memcpy(to->computeWorkGroupSize, from->computeWorkGroupSize, 3 * sizeof(uint32_t));
}

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
    BumpPool* pool,
    const VkStreamDescriptorSurfaceCreateInfoGGP* from,
    VkStreamDescriptorSurfaceCreateInfoGGP* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
    VkPhysicalDeviceCornerSampledImageFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void deepcopy_VkExternalImageFormatPropertiesNV(
    BumpPool* pool,
    const VkExternalImageFormatPropertiesNV* from,
    VkExternalImageFormatPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
}

#endif
#ifdef VK_NV_external_memory
void deepcopy_VkExternalMemoryImageCreateInfoNV(
    BumpPool* pool,
    const VkExternalMemoryImageCreateInfoNV* from,
    VkExternalMemoryImageCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportMemoryAllocateInfoNV(
    BumpPool* pool,
    const VkExportMemoryAllocateInfoNV* from,
    VkExportMemoryAllocateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoNV(
    BumpPool* pool,
    const VkImportMemoryWin32HandleInfoNV* from,
    VkImportMemoryWin32HandleInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExportMemoryWin32HandleInfoNV(
    BumpPool* pool,
    const VkExportMemoryWin32HandleInfoNV* from,
    VkExportMemoryWin32HandleInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAttributes = nullptr;
    if (from->pAttributes)
    {
        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
    }
}

#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
    BumpPool* pool,
    const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
    VkWin32KeyedMutexAcquireReleaseInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAcquireSyncs = nullptr;
    if (from->pAcquireSyncs)
    {
        to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
    }
    to->pAcquireKeys = nullptr;
    if (from->pAcquireKeys)
    {
        to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
    }
    to->pAcquireTimeoutMilliseconds = nullptr;
    if (from->pAcquireTimeoutMilliseconds)
    {
        to->pAcquireTimeoutMilliseconds = (uint32_t*)pool->dupArray(from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
    }
    to->pReleaseSyncs = nullptr;
    if (from->pReleaseSyncs)
    {
        to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
    }
    to->pReleaseKeys = nullptr;
    if (from->pReleaseKeys)
    {
        to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
    }
}

#endif
#ifdef VK_EXT_validation_flags
void deepcopy_VkValidationFlagsEXT(
    BumpPool* pool,
    const VkValidationFlagsEXT* from,
    VkValidationFlagsEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDisabledValidationChecks = nullptr;
    if (from->pDisabledValidationChecks)
    {
        to->pDisabledValidationChecks = (VkValidationCheckEXT*)pool->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
    }
}

#endif
#ifdef VK_NN_vi_surface
void deepcopy_VkViSurfaceCreateInfoNN(
    BumpPool* pool,
    const VkViSurfaceCreateInfoNN* from,
    VkViSurfaceCreateInfoNN* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->window = nullptr;
    if (from->window)
    {
        to->window = (void*)pool->dupArray(from->window, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_astc_decode_mode
void deepcopy_VkImageViewASTCDecodeModeEXT(
    BumpPool* pool,
    const VkImageViewASTCDecodeModeEXT* from,
    VkImageViewASTCDecodeModeEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
    VkPhysicalDeviceASTCDecodeFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_conditional_rendering
void deepcopy_VkConditionalRenderingBeginInfoEXT(
    BumpPool* pool,
    const VkConditionalRenderingBeginInfoEXT* from,
    VkConditionalRenderingBeginInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
    VkPhysicalDeviceConditionalRenderingFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    BumpPool* pool,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
    VkCommandBufferInheritanceConditionalRenderingInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_clip_space_w_scaling
void deepcopy_VkViewportWScalingNV(
    BumpPool* pool,
    const VkViewportWScalingNV* from,
    VkViewportWScalingNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineViewportWScalingStateCreateInfoNV* from,
    VkPipelineViewportWScalingStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pViewportWScalings = nullptr;
        if (from->pViewportWScalings)
        {
            to->pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportWScalingNV));
            to->viewportCount = from->viewportCount;
            for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
            {
                deepcopy_VkViewportWScalingNV(pool, from->pViewportWScalings + i, (VkViewportWScalingNV*)(to->pViewportWScalings + i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
void deepcopy_VkSurfaceCapabilities2EXT(
    BumpPool* pool,
    const VkSurfaceCapabilities2EXT* from,
    VkSurfaceCapabilities2EXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
    deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
    deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
}

#endif
#ifdef VK_EXT_display_control
void deepcopy_VkDisplayPowerInfoEXT(
    BumpPool* pool,
    const VkDisplayPowerInfoEXT* from,
    VkDisplayPowerInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceEventInfoEXT(
    BumpPool* pool,
    const VkDeviceEventInfoEXT* from,
    VkDeviceEventInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDisplayEventInfoEXT(
    BumpPool* pool,
    const VkDisplayEventInfoEXT* from,
    VkDisplayEventInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSwapchainCounterCreateInfoEXT(
    BumpPool* pool,
    const VkSwapchainCounterCreateInfoEXT* from,
    VkSwapchainCounterCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_GOOGLE_display_timing
void deepcopy_VkRefreshCycleDurationGOOGLE(
    BumpPool* pool,
    const VkRefreshCycleDurationGOOGLE* from,
    VkRefreshCycleDurationGOOGLE* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPastPresentationTimingGOOGLE(
    BumpPool* pool,
    const VkPastPresentationTimingGOOGLE* from,
    VkPastPresentationTimingGOOGLE* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPresentTimeGOOGLE(
    BumpPool* pool,
    const VkPresentTimeGOOGLE* from,
    VkPresentTimeGOOGLE* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPresentTimesInfoGOOGLE(
    BumpPool* pool,
    const VkPresentTimesInfoGOOGLE* from,
    VkPresentTimesInfoGOOGLE* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pTimes = nullptr;
        if (from->pTimes)
        {
            to->pTimes = (VkPresentTimeGOOGLE*)pool->alloc(from->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
            to->swapchainCount = from->swapchainCount;
            for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
            {
                deepcopy_VkPresentTimeGOOGLE(pool, from->pTimes + i, (VkPresentTimeGOOGLE*)(to->pTimes + i));
            }
        }
    }
}

#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
void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    BumpPool* pool,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_viewport_swizzle
void deepcopy_VkViewportSwizzleNV(
    BumpPool* pool,
    const VkViewportSwizzleNV* from,
    VkViewportSwizzleNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineViewportSwizzleStateCreateInfoNV* from,
    VkPipelineViewportSwizzleStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pViewportSwizzles = nullptr;
        if (from->pViewportSwizzles)
        {
            to->pViewportSwizzles = (VkViewportSwizzleNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportSwizzleNV));
            to->viewportCount = from->viewportCount;
            for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
            {
                deepcopy_VkViewportSwizzleNV(pool, from->pViewportSwizzles + i, (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
    VkPhysicalDeviceDiscardRectanglePropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
    VkPipelineDiscardRectangleStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pDiscardRectangles = nullptr;
        if (from->pDiscardRectangles)
        {
            to->pDiscardRectangles = (VkRect2D*)pool->alloc(from->discardRectangleCount * sizeof(const VkRect2D));
            to->discardRectangleCount = from->discardRectangleCount;
            for (uint32_t i = 0; i < (uint32_t)from->discardRectangleCount; ++i)
            {
                deepcopy_VkRect2D(pool, from->pDiscardRectangles + i, (VkRect2D*)(to->pDiscardRectangles + i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
    VkPipelineRasterizationConservativeStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
    VkPhysicalDeviceDepthClipEnableFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
    VkPipelineRasterizationDepthClipStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void deepcopy_VkXYColorEXT(
    BumpPool* pool,
    const VkXYColorEXT* from,
    VkXYColorEXT* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkHdrMetadataEXT(
    BumpPool* pool,
    const VkHdrMetadataEXT* from,
    VkHdrMetadataEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryRed, (VkXYColorEXT*)(&to->displayPrimaryRed));
    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryGreen, (VkXYColorEXT*)(&to->displayPrimaryGreen));
    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryBlue, (VkXYColorEXT*)(&to->displayPrimaryBlue));
    deepcopy_VkXYColorEXT(pool, &from->whitePoint, (VkXYColorEXT*)(&to->whitePoint));
}

#endif
#ifdef VK_MVK_ios_surface
void deepcopy_VkIOSSurfaceCreateInfoMVK(
    BumpPool* pool,
    const VkIOSSurfaceCreateInfoMVK* from,
    VkIOSSurfaceCreateInfoMVK* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pView = nullptr;
    if (from->pView)
    {
        to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
    }
}

#endif
#ifdef VK_MVK_macos_surface
void deepcopy_VkMacOSSurfaceCreateInfoMVK(
    BumpPool* pool,
    const VkMacOSSurfaceCreateInfoMVK* from,
    VkMacOSSurfaceCreateInfoMVK* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pView = nullptr;
    if (from->pView)
    {
        to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
    }
}

#endif
#ifdef VK_MVK_moltenvk
#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void deepcopy_VkDebugUtilsLabelEXT(
    BumpPool* pool,
    const VkDebugUtilsLabelEXT* from,
    VkDebugUtilsLabelEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pLabelName = nullptr;
    if (from->pLabelName)
    {
        to->pLabelName = pool->strDup(from->pLabelName);
    }
    memcpy(to->color, from->color, 4 * sizeof(float));
}

void deepcopy_VkDebugUtilsObjectNameInfoEXT(
    BumpPool* pool,
    const VkDebugUtilsObjectNameInfoEXT* from,
    VkDebugUtilsObjectNameInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pObjectName = nullptr;
    if (from->pObjectName)
    {
        to->pObjectName = pool->strDup(from->pObjectName);
    }
}

void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
    BumpPool* pool,
    const VkDebugUtilsMessengerCallbackDataEXT* from,
    VkDebugUtilsMessengerCallbackDataEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pMessageIdName = nullptr;
    if (from->pMessageIdName)
    {
        to->pMessageIdName = pool->strDup(from->pMessageIdName);
    }
    to->pMessage = nullptr;
    if (from->pMessage)
    {
        to->pMessage = pool->strDup(from->pMessage);
    }
    if (from)
    {
        to->pQueueLabels = nullptr;
        if (from->pQueueLabels)
        {
            to->pQueueLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
            to->queueLabelCount = from->queueLabelCount;
            for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i)
            {
                deepcopy_VkDebugUtilsLabelEXT(pool, from->pQueueLabels + i, (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
            }
        }
    }
    if (from)
    {
        to->pCmdBufLabels = nullptr;
        if (from->pCmdBufLabels)
        {
            to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
            to->cmdBufLabelCount = from->cmdBufLabelCount;
            for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i)
            {
                deepcopy_VkDebugUtilsLabelEXT(pool, from->pCmdBufLabels + i, (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
            }
        }
    }
    if (from)
    {
        to->pObjects = nullptr;
        if (from->pObjects)
        {
            to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
            to->objectCount = from->objectCount;
            for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i)
            {
                deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, from->pObjects + i, (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
            }
        }
    }
}

void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
    BumpPool* pool,
    const VkDebugUtilsMessengerCreateInfoEXT* from,
    VkDebugUtilsMessengerCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pUserData = nullptr;
    if (from->pUserData)
    {
        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
    }
}

void deepcopy_VkDebugUtilsObjectTagInfoEXT(
    BumpPool* pool,
    const VkDebugUtilsObjectTagInfoEXT* from,
    VkDebugUtilsObjectTagInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pTag = nullptr;
    if (from->pTag)
    {
        to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
    }
}

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void deepcopy_VkAndroidHardwareBufferUsageANDROID(
    BumpPool* pool,
    const VkAndroidHardwareBufferUsageANDROID* from,
    VkAndroidHardwareBufferUsageANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
    BumpPool* pool,
    const VkAndroidHardwareBufferPropertiesANDROID* from,
    VkAndroidHardwareBufferPropertiesANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
    BumpPool* pool,
    const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
    VkAndroidHardwareBufferFormatPropertiesANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkComponentMapping(pool, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
}

void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
    BumpPool* pool,
    const VkImportAndroidHardwareBufferInfoANDROID* from,
    VkImportAndroidHardwareBufferInfoANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->buffer = nullptr;
    if (from->buffer)
    {
        to->buffer = (AHardwareBuffer*)pool->dupArray(from->buffer, sizeof(AHardwareBuffer));
    }
}

void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    BumpPool* pool,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
    VkMemoryGetAndroidHardwareBufferInfoANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkExternalFormatANDROID(
    BumpPool* pool,
    const VkExternalFormatANDROID* from,
    VkExternalFormatANDROID* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#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_inline_uniform_block
void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
    BumpPool* pool,
    const VkWriteDescriptorSetInlineUniformBlockEXT* from,
    VkWriteDescriptorSetInlineUniformBlockEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pData = nullptr;
    if (from->pData)
    {
        to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
    }
}

void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
    BumpPool* pool,
    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
void deepcopy_VkSampleLocationEXT(
    BumpPool* pool,
    const VkSampleLocationEXT* from,
    VkSampleLocationEXT* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSampleLocationsInfoEXT(
    BumpPool* pool,
    const VkSampleLocationsInfoEXT* from,
    VkSampleLocationsInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
    if (from)
    {
        to->pSampleLocations = nullptr;
        if (from->pSampleLocations)
        {
            to->pSampleLocations = (VkSampleLocationEXT*)pool->alloc(from->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
            to->sampleLocationsCount = from->sampleLocationsCount;
            for (uint32_t i = 0; i < (uint32_t)from->sampleLocationsCount; ++i)
            {
                deepcopy_VkSampleLocationEXT(pool, from->pSampleLocations + i, (VkSampleLocationEXT*)(to->pSampleLocations + i));
            }
        }
    }
}

void deepcopy_VkAttachmentSampleLocationsEXT(
    BumpPool* pool,
    const VkAttachmentSampleLocationsEXT* from,
    VkAttachmentSampleLocationsEXT* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}

void deepcopy_VkSubpassSampleLocationsEXT(
    BumpPool* pool,
    const VkSubpassSampleLocationsEXT* from,
    VkSubpassSampleLocationsEXT* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}

void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
    BumpPool* pool,
    const VkRenderPassSampleLocationsBeginInfoEXT* from,
    VkRenderPassSampleLocationsBeginInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pAttachmentInitialSampleLocations = nullptr;
        if (from->pAttachmentInitialSampleLocations)
        {
            to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)pool->alloc(from->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
            to->attachmentInitialSampleLocationsCount = from->attachmentInitialSampleLocationsCount;
            for (uint32_t i = 0; i < (uint32_t)from->attachmentInitialSampleLocationsCount; ++i)
            {
                deepcopy_VkAttachmentSampleLocationsEXT(pool, from->pAttachmentInitialSampleLocations + i, (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
            }
        }
    }
    if (from)
    {
        to->pPostSubpassSampleLocations = nullptr;
        if (from->pPostSubpassSampleLocations)
        {
            to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)pool->alloc(from->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
            to->postSubpassSampleLocationsCount = from->postSubpassSampleLocationsCount;
            for (uint32_t i = 0; i < (uint32_t)from->postSubpassSampleLocationsCount; ++i)
            {
                deepcopy_VkSubpassSampleLocationsEXT(pool, from->pPostSubpassSampleLocations + i, (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
            }
        }
    }
}

void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineSampleLocationsStateCreateInfoEXT* from,
    VkPipelineSampleLocationsStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}

void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
    VkPhysicalDeviceSampleLocationsPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
    memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange, 2 * sizeof(float));
}

void deepcopy_VkMultisamplePropertiesEXT(
    BumpPool* pool,
    const VkMultisamplePropertiesEXT* from,
    VkMultisamplePropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
}

#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
    VkPipelineColorBlendAdvancedStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineCoverageToColorStateCreateInfoNV* from,
    VkPipelineCoverageToColorStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineCoverageModulationStateCreateInfoNV* from,
    VkPipelineCoverageModulationStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pCoverageModulationTable = nullptr;
    if (from->pCoverageModulationTable)
    {
        to->pCoverageModulationTable = (float*)pool->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
    }
}

#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void deepcopy_VkDrmFormatModifierPropertiesEXT(
    BumpPool* pool,
    const VkDrmFormatModifierPropertiesEXT* from,
    VkDrmFormatModifierPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkDrmFormatModifierPropertiesListEXT(
    BumpPool* pool,
    const VkDrmFormatModifierPropertiesListEXT* from,
    VkDrmFormatModifierPropertiesListEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pDrmFormatModifierProperties = nullptr;
        if (from->pDrmFormatModifierProperties)
        {
            to->pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT*)pool->alloc(from->drmFormatModifierCount * sizeof(VkDrmFormatModifierPropertiesEXT));
            to->drmFormatModifierCount = from->drmFormatModifierCount;
            for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierCount; ++i)
            {
                deepcopy_VkDrmFormatModifierPropertiesEXT(pool, from->pDrmFormatModifierProperties + i, (VkDrmFormatModifierPropertiesEXT*)(to->pDrmFormatModifierProperties + i));
            }
        }
    }
}

void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
    BumpPool* pool,
    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
    VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pQueueFamilyIndices = nullptr;
    if (from->pQueueFamilyIndices)
    {
        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
    BumpPool* pool,
    const VkImageDrmFormatModifierListCreateInfoEXT* from,
    VkImageDrmFormatModifierListCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDrmFormatModifiers = nullptr;
    if (from->pDrmFormatModifiers)
    {
        to->pDrmFormatModifiers = (uint64_t*)pool->dupArray(from->pDrmFormatModifiers, from->drmFormatModifierCount * sizeof(const uint64_t));
    }
}

void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
    BumpPool* pool,
    const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
    VkImageDrmFormatModifierExplicitCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pPlaneLayouts = nullptr;
        if (from->pPlaneLayouts)
        {
            to->pPlaneLayouts = (VkSubresourceLayout*)pool->alloc(from->drmFormatModifierPlaneCount * sizeof(const VkSubresourceLayout));
            to->drmFormatModifierPlaneCount = from->drmFormatModifierPlaneCount;
            for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierPlaneCount; ++i)
            {
                deepcopy_VkSubresourceLayout(pool, from->pPlaneLayouts + i, (VkSubresourceLayout*)(to->pPlaneLayouts + i));
            }
        }
    }
}

void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
    BumpPool* pool,
    const VkImageDrmFormatModifierPropertiesEXT* from,
    VkImageDrmFormatModifierPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_validation_cache
void deepcopy_VkValidationCacheCreateInfoEXT(
    BumpPool* pool,
    const VkValidationCacheCreateInfoEXT* from,
    VkValidationCacheCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pInitialData = nullptr;
    if (from->pInitialData)
    {
        to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
    }
}

void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
    BumpPool* pool,
    const VkShaderModuleValidationCacheCreateInfoEXT* from,
    VkShaderModuleValidationCacheCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_descriptor_indexing
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
void deepcopy_VkShadingRatePaletteNV(
    BumpPool* pool,
    const VkShadingRatePaletteNV* from,
    VkShadingRatePaletteNV* to)
{
    (void)pool;
    *to = *from;
    to->pShadingRatePaletteEntries = nullptr;
    if (from->pShadingRatePaletteEntries)
    {
        to->pShadingRatePaletteEntries = (VkShadingRatePaletteEntryNV*)pool->dupArray(from->pShadingRatePaletteEntries, from->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
    }
}

void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
    VkPipelineViewportShadingRateImageStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pShadingRatePalettes = nullptr;
        if (from->pShadingRatePalettes)
        {
            to->pShadingRatePalettes = (VkShadingRatePaletteNV*)pool->alloc(from->viewportCount * sizeof(const VkShadingRatePaletteNV));
            to->viewportCount = from->viewportCount;
            for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
            {
                deepcopy_VkShadingRatePaletteNV(pool, from->pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(to->pShadingRatePalettes + i));
            }
        }
    }
}

void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
    VkPhysicalDeviceShadingRateImageFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
    VkPhysicalDeviceShadingRateImagePropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkExtent2D(pool, &from->shadingRateTexelSize, (VkExtent2D*)(&to->shadingRateTexelSize));
}

void deepcopy_VkCoarseSampleLocationNV(
    BumpPool* pool,
    const VkCoarseSampleLocationNV* from,
    VkCoarseSampleLocationNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkCoarseSampleOrderCustomNV(
    BumpPool* pool,
    const VkCoarseSampleOrderCustomNV* from,
    VkCoarseSampleOrderCustomNV* to)
{
    (void)pool;
    *to = *from;
    if (from)
    {
        to->pSampleLocations = nullptr;
        if (from->pSampleLocations)
        {
            to->pSampleLocations = (VkCoarseSampleLocationNV*)pool->alloc(from->sampleLocationCount * sizeof(const VkCoarseSampleLocationNV));
            to->sampleLocationCount = from->sampleLocationCount;
            for (uint32_t i = 0; i < (uint32_t)from->sampleLocationCount; ++i)
            {
                deepcopy_VkCoarseSampleLocationNV(pool, from->pSampleLocations + i, (VkCoarseSampleLocationNV*)(to->pSampleLocations + i));
            }
        }
    }
}

void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pCustomSampleOrders = nullptr;
        if (from->pCustomSampleOrders)
        {
            to->pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)pool->alloc(from->customSampleOrderCount * sizeof(const VkCoarseSampleOrderCustomNV));
            to->customSampleOrderCount = from->customSampleOrderCount;
            for (uint32_t i = 0; i < (uint32_t)from->customSampleOrderCount; ++i)
            {
                deepcopy_VkCoarseSampleOrderCustomNV(pool, from->pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(to->pCustomSampleOrders + i));
            }
        }
    }
}

#endif
#ifdef VK_NV_ray_tracing
void deepcopy_VkRayTracingShaderGroupCreateInfoNV(
    BumpPool* pool,
    const VkRayTracingShaderGroupCreateInfoNV* from,
    VkRayTracingShaderGroupCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkRayTracingPipelineCreateInfoNV(
    BumpPool* pool,
    const VkRayTracingPipelineCreateInfoNV* from,
    VkRayTracingPipelineCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pStages = nullptr;
        if (from->pStages)
        {
            to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
            to->stageCount = from->stageCount;
            for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
            {
                deepcopy_VkPipelineShaderStageCreateInfo(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
            }
        }
    }
    if (from)
    {
        to->pGroups = nullptr;
        if (from->pGroups)
        {
            to->pGroups = (VkRayTracingShaderGroupCreateInfoNV*)pool->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoNV));
            to->groupCount = from->groupCount;
            for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
            {
                deepcopy_VkRayTracingShaderGroupCreateInfoNV(pool, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoNV*)(to->pGroups + i));
            }
        }
    }
}

void deepcopy_VkGeometryTrianglesNV(
    BumpPool* pool,
    const VkGeometryTrianglesNV* from,
    VkGeometryTrianglesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkGeometryAABBNV(
    BumpPool* pool,
    const VkGeometryAABBNV* from,
    VkGeometryAABBNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkGeometryDataNV(
    BumpPool* pool,
    const VkGeometryDataNV* from,
    VkGeometryDataNV* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkGeometryTrianglesNV(pool, &from->triangles, (VkGeometryTrianglesNV*)(&to->triangles));
    deepcopy_VkGeometryAABBNV(pool, &from->aabbs, (VkGeometryAABBNV*)(&to->aabbs));
}

void deepcopy_VkGeometryNV(
    BumpPool* pool,
    const VkGeometryNV* from,
    VkGeometryNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkGeometryDataNV(pool, &from->geometry, (VkGeometryDataNV*)(&to->geometry));
}

void deepcopy_VkAccelerationStructureInfoNV(
    BumpPool* pool,
    const VkAccelerationStructureInfoNV* from,
    VkAccelerationStructureInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pGeometries = nullptr;
        if (from->pGeometries)
        {
            to->pGeometries = (VkGeometryNV*)pool->alloc(from->geometryCount * sizeof(const VkGeometryNV));
            to->geometryCount = from->geometryCount;
            for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i)
            {
                deepcopy_VkGeometryNV(pool, from->pGeometries + i, (VkGeometryNV*)(to->pGeometries + i));
            }
        }
    }
}

void deepcopy_VkAccelerationStructureCreateInfoNV(
    BumpPool* pool,
    const VkAccelerationStructureCreateInfoNV* from,
    VkAccelerationStructureCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkAccelerationStructureInfoNV(pool, &from->info, (VkAccelerationStructureInfoNV*)(&to->info));
}

void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
    BumpPool* pool,
    const VkBindAccelerationStructureMemoryInfoNV* from,
    VkBindAccelerationStructureMemoryInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pDeviceIndices = nullptr;
    if (from->pDeviceIndices)
    {
        to->pDeviceIndices = (uint32_t*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
    BumpPool* pool,
    const VkWriteDescriptorSetAccelerationStructureNV* from,
    VkWriteDescriptorSetAccelerationStructureNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAccelerationStructures = nullptr;
    if (from->pAccelerationStructures)
    {
        to->pAccelerationStructures = (VkAccelerationStructureNV*)pool->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
    }
}

void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
    BumpPool* pool,
    const VkAccelerationStructureMemoryRequirementsInfoNV* from,
    VkAccelerationStructureMemoryRequirementsInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceRayTracingPropertiesNV* from,
    VkPhysicalDeviceRayTracingPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkTransformMatrixKHR(
    BumpPool* pool,
    const VkTransformMatrixKHR* from,
    VkTransformMatrixKHR* to)
{
    (void)pool;
    *to = *from;
    memcpy(to->matrix, from->matrix, ((3)*(4)) * sizeof(float));
}

void deepcopy_VkAabbPositionsKHR(
    BumpPool* pool,
    const VkAabbPositionsKHR* from,
    VkAabbPositionsKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkAccelerationStructureInstanceKHR(
    BumpPool* pool,
    const VkAccelerationStructureInstanceKHR* from,
    VkAccelerationStructureInstanceKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkTransformMatrixKHR(pool, &from->transform, (VkTransformMatrixKHR*)(&to->transform));
}

#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
    VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
    BumpPool* pool,
    const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
    VkPhysicalDeviceImageViewImageFormatInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
    BumpPool* pool,
    const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
    VkFilterCubicImageViewImageFormatPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
    BumpPool* pool,
    const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
    VkDeviceQueueGlobalPriorityCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_external_memory_host
void deepcopy_VkImportMemoryHostPointerInfoEXT(
    BumpPool* pool,
    const VkImportMemoryHostPointerInfoEXT* from,
    VkImportMemoryHostPointerInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pHostPointer = nullptr;
    if (from->pHostPointer)
    {
        to->pHostPointer = (void*)pool->dupArray(from->pHostPointer, sizeof(uint8_t));
    }
}

void deepcopy_VkMemoryHostPointerPropertiesEXT(
    BumpPool* pool,
    const VkMemoryHostPointerPropertiesEXT* from,
    VkMemoryHostPointerPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
    BumpPool* pool,
    const VkPipelineCompilerControlCreateInfoAMD* from,
    VkPipelineCompilerControlCreateInfoAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_calibrated_timestamps
void deepcopy_VkCalibratedTimestampInfoEXT(
    BumpPool* pool,
    const VkCalibratedTimestampInfoEXT* from,
    VkCalibratedTimestampInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
    BumpPool* pool,
    const VkPhysicalDeviceShaderCorePropertiesAMD* from,
    VkPhysicalDeviceShaderCorePropertiesAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
    BumpPool* pool,
    const VkDeviceMemoryOverallocationCreateInfoAMD* from,
    VkDeviceMemoryOverallocationCreateInfoAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
    BumpPool* pool,
    const VkVertexInputBindingDivisorDescriptionEXT* from,
    VkVertexInputBindingDivisorDescriptionEXT* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
    VkPipelineVertexInputDivisorStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pVertexBindingDivisors = nullptr;
        if (from->pVertexBindingDivisors)
        {
            to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)pool->alloc(from->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
            to->vertexBindingDivisorCount = from->vertexBindingDivisorCount;
            for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDivisorCount; ++i)
            {
                deepcopy_VkVertexInputBindingDivisorDescriptionEXT(pool, from->pVertexBindingDivisors + i, (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
            }
        }
    }
}

void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
    VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_GGP_frame_token
void deepcopy_VkPresentFrameTokenGGP(
    BumpPool* pool,
    const VkPresentFrameTokenGGP* from,
    VkPresentFrameTokenGGP* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_pipeline_creation_feedback
void deepcopy_VkPipelineCreationFeedbackEXT(
    BumpPool* pool,
    const VkPipelineCreationFeedbackEXT* from,
    VkPipelineCreationFeedbackEXT* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineCreationFeedbackCreateInfoEXT* from,
    VkPipelineCreationFeedbackCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pPipelineCreationFeedback = nullptr;
    if (from->pPipelineCreationFeedback)
    {
        to->pPipelineCreationFeedback = (VkPipelineCreationFeedbackEXT*)pool->alloc(sizeof(VkPipelineCreationFeedbackEXT));
        deepcopy_VkPipelineCreationFeedbackEXT(pool, from->pPipelineCreationFeedback, (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
    }
    if (from)
    {
        to->pPipelineStageCreationFeedbacks = nullptr;
        if (from->pPipelineStageCreationFeedbacks)
        {
            to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedbackEXT*)pool->alloc(from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedbackEXT));
            to->pipelineStageCreationFeedbackCount = from->pipelineStageCreationFeedbackCount;
            for (uint32_t i = 0; i < (uint32_t)from->pipelineStageCreationFeedbackCount; ++i)
            {
                deepcopy_VkPipelineCreationFeedbackEXT(pool, from->pPipelineStageCreationFeedbacks + i, (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
            }
        }
    }
}

#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_mesh_shader
void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceMeshShaderFeaturesNV* from,
    VkPhysicalDeviceMeshShaderFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceMeshShaderPropertiesNV* from,
    VkPhysicalDeviceMeshShaderPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->maxTaskWorkGroupSize, from->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
    memcpy(to->maxMeshWorkGroupSize, from->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
}

void deepcopy_VkDrawMeshTasksIndirectCommandNV(
    BumpPool* pool,
    const VkDrawMeshTasksIndirectCommandNV* from,
    VkDrawMeshTasksIndirectCommandNV* to)
{
    (void)pool;
    *to = *from;
}

#endif
#ifdef VK_NV_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
    VkPhysicalDeviceShaderImageFootprintFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
    VkPipelineViewportExclusiveScissorStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pExclusiveScissors = nullptr;
        if (from->pExclusiveScissors)
        {
            to->pExclusiveScissors = (VkRect2D*)pool->alloc(from->exclusiveScissorCount * sizeof(const VkRect2D));
            to->exclusiveScissorCount = from->exclusiveScissorCount;
            for (uint32_t i = 0; i < (uint32_t)from->exclusiveScissorCount; ++i)
            {
                deepcopy_VkRect2D(pool, from->pExclusiveScissors + i, (VkRect2D*)(to->pExclusiveScissors + i));
            }
        }
    }
}

void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
    VkPhysicalDeviceExclusiveScissorFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
    BumpPool* pool,
    const VkQueueFamilyCheckpointPropertiesNV* from,
    VkQueueFamilyCheckpointPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCheckpointDataNV(
    BumpPool* pool,
    const VkCheckpointDataNV* from,
    VkCheckpointDataNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pCheckpointMarker = nullptr;
    if (from->pCheckpointMarker)
    {
        to->pCheckpointMarker = (void*)pool->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
    BumpPool* pool,
    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_INTEL_performance_query
void deepcopy_VkPerformanceValueDataINTEL(
    BumpPool* pool,
    const VkPerformanceValueDataINTEL* from,
    VkPerformanceValueDataINTEL* to)
{
    (void)pool;
    *to = *from;
    to->valueString = nullptr;
    if (from->valueString)
    {
        to->valueString = pool->strDup(from->valueString);
    }
}

void deepcopy_VkPerformanceValueINTEL(
    BumpPool* pool,
    const VkPerformanceValueINTEL* from,
    VkPerformanceValueINTEL* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkPerformanceValueDataINTEL(pool, &from->data, (VkPerformanceValueDataINTEL*)(&to->data));
}

void deepcopy_VkInitializePerformanceApiInfoINTEL(
    BumpPool* pool,
    const VkInitializePerformanceApiInfoINTEL* from,
    VkInitializePerformanceApiInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pUserData = nullptr;
    if (from->pUserData)
    {
        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
    }
}

void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
    BumpPool* pool,
    const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
    VkQueryPoolPerformanceQueryCreateInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceMarkerInfoINTEL(
    BumpPool* pool,
    const VkPerformanceMarkerInfoINTEL* from,
    VkPerformanceMarkerInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceStreamMarkerInfoINTEL(
    BumpPool* pool,
    const VkPerformanceStreamMarkerInfoINTEL* from,
    VkPerformanceStreamMarkerInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceOverrideInfoINTEL(
    BumpPool* pool,
    const VkPerformanceOverrideInfoINTEL* from,
    VkPerformanceOverrideInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
    BumpPool* pool,
    const VkPerformanceConfigurationAcquireInfoINTEL* from,
    VkPerformanceConfigurationAcquireInfoINTEL* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
    VkPhysicalDevicePCIBusInfoPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
    BumpPool* pool,
    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
    VkDisplayNativeHdrSurfaceCapabilitiesAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
    BumpPool* pool,
    const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
    VkSwapchainDisplayNativeHdrCreateInfoAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
    BumpPool* pool,
    const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
    VkImagePipeSurfaceCreateInfoFUCHSIA* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_metal_surface
void deepcopy_VkMetalSurfaceCreateInfoEXT(
    BumpPool* pool,
    const VkMetalSurfaceCreateInfoEXT* from,
    VkMetalSurfaceCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pLayer = nullptr;
    if (from->pLayer)
    {
        to->pLayer = (CAMetalLayer*)pool->dupArray(from->pLayer, sizeof(const CAMetalLayer));
    }
}

#endif
#ifdef VK_GOOGLE_color_buffer
void deepcopy_VkImportColorBufferGOOGLE(
    BumpPool* pool,
    const VkImportColorBufferGOOGLE* from,
    VkImportColorBufferGOOGLE* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImportBufferGOOGLE(
    BumpPool* pool,
    const VkImportBufferGOOGLE* from,
    VkImportBufferGOOGLE* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkImportPhysicalAddressGOOGLE(
    BumpPool* pool,
    const VkImportPhysicalAddressGOOGLE* from,
    VkImportPhysicalAddressGOOGLE* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_scalar_block_layout
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
#endif
#ifdef VK_GOOGLE_decorate_string
#endif
#ifdef VK_EXT_subgroup_size_control
void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
    BumpPool* pool,
    const VkPhysicalDeviceShaderCoreProperties2AMD* from,
    VkPhysicalDeviceShaderCoreProperties2AMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
    BumpPool* pool,
    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
    VkPhysicalDeviceCoherentMemoryFeaturesAMD* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
    VkPhysicalDeviceMemoryBudgetPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->heapBudget, from->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
    memcpy(to->heapUsage, from->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
}

#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
    VkPhysicalDeviceMemoryPriorityFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkMemoryPriorityAllocateInfoEXT(
    BumpPool* pool,
    const VkMemoryPriorityAllocateInfoEXT* from,
    VkMemoryPriorityAllocateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkBufferDeviceAddressCreateInfoEXT(
    BumpPool* pool,
    const VkBufferDeviceAddressCreateInfoEXT* from,
    VkBufferDeviceAddressCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_tooling_info
void deepcopy_VkPhysicalDeviceToolPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceToolPropertiesEXT* from,
    VkPhysicalDeviceToolPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->name, from->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    memcpy(to->version, from->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    memcpy(to->layer, from->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}

#endif
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
void deepcopy_VkValidationFeaturesEXT(
    BumpPool* pool,
    const VkValidationFeaturesEXT* from,
    VkValidationFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pEnabledValidationFeatures = nullptr;
    if (from->pEnabledValidationFeatures)
    {
        to->pEnabledValidationFeatures = (VkValidationFeatureEnableEXT*)pool->dupArray(from->pEnabledValidationFeatures, from->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
    }
    to->pDisabledValidationFeatures = nullptr;
    if (from->pDisabledValidationFeatures)
    {
        to->pDisabledValidationFeatures = (VkValidationFeatureDisableEXT*)pool->dupArray(from->pDisabledValidationFeatures, from->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
    }
}

#endif
#ifdef VK_NV_cooperative_matrix
void deepcopy_VkCooperativeMatrixPropertiesNV(
    BumpPool* pool,
    const VkCooperativeMatrixPropertiesNV* from,
    VkCooperativeMatrixPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
    VkPhysicalDeviceCooperativeMatrixFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
    VkPhysicalDeviceCooperativeMatrixPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
    VkPhysicalDeviceCoverageReductionModeFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineCoverageReductionStateCreateInfoNV* from,
    VkPipelineCoverageReductionStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkFramebufferMixedSamplesCombinationNV(
    BumpPool* pool,
    const VkFramebufferMixedSamplesCombinationNV* from,
    VkFramebufferMixedSamplesCombinationNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_full_screen_exclusive
void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
    BumpPool* pool,
    const VkSurfaceFullScreenExclusiveInfoEXT* from,
    VkSurfaceFullScreenExclusiveInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
    BumpPool* pool,
    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
    VkSurfaceCapabilitiesFullScreenExclusiveEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
    BumpPool* pool,
    const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
    VkSurfaceFullScreenExclusiveWin32InfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_headless_surface
void deepcopy_VkHeadlessSurfaceCreateInfoEXT(
    BumpPool* pool,
    const VkHeadlessSurfaceCreateInfoEXT* from,
    VkHeadlessSurfaceCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
    VkPhysicalDeviceLineRasterizationFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
    VkPhysicalDeviceLineRasterizationPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
    BumpPool* pool,
    const VkPipelineRasterizationLineStateCreateInfoEXT* from,
    VkPipelineRasterizationLineStateCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_host_query_reset
#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
    VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkGraphicsShaderGroupCreateInfoNV(
    BumpPool* pool,
    const VkGraphicsShaderGroupCreateInfoNV* from,
    VkGraphicsShaderGroupCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pStages = nullptr;
        if (from->pStages)
        {
            to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
            to->stageCount = from->stageCount;
            for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
            {
                deepcopy_VkPipelineShaderStageCreateInfo(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
            }
        }
    }
    to->pVertexInputState = nullptr;
    if (from->pVertexInputState)
    {
        to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
        deepcopy_VkPipelineVertexInputStateCreateInfo(pool, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
    }
    to->pTessellationState = nullptr;
    if (from->pTessellationState)
    {
        to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
        deepcopy_VkPipelineTessellationStateCreateInfo(pool, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
    }
}

void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
    BumpPool* pool,
    const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
    VkGraphicsPipelineShaderGroupsCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pGroups = nullptr;
        if (from->pGroups)
        {
            to->pGroups = (VkGraphicsShaderGroupCreateInfoNV*)pool->alloc(from->groupCount * sizeof(const VkGraphicsShaderGroupCreateInfoNV));
            to->groupCount = from->groupCount;
            for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
            {
                deepcopy_VkGraphicsShaderGroupCreateInfoNV(pool, from->pGroups + i, (VkGraphicsShaderGroupCreateInfoNV*)(to->pGroups + i));
            }
        }
    }
    to->pPipelines = nullptr;
    if (from->pPipelines)
    {
        to->pPipelines = (VkPipeline*)pool->dupArray(from->pPipelines, from->pipelineCount * sizeof(const VkPipeline));
    }
}

void deepcopy_VkBindShaderGroupIndirectCommandNV(
    BumpPool* pool,
    const VkBindShaderGroupIndirectCommandNV* from,
    VkBindShaderGroupIndirectCommandNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkBindIndexBufferIndirectCommandNV(
    BumpPool* pool,
    const VkBindIndexBufferIndirectCommandNV* from,
    VkBindIndexBufferIndirectCommandNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkBindVertexBufferIndirectCommandNV(
    BumpPool* pool,
    const VkBindVertexBufferIndirectCommandNV* from,
    VkBindVertexBufferIndirectCommandNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkSetStateFlagsIndirectCommandNV(
    BumpPool* pool,
    const VkSetStateFlagsIndirectCommandNV* from,
    VkSetStateFlagsIndirectCommandNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkIndirectCommandsStreamNV(
    BumpPool* pool,
    const VkIndirectCommandsStreamNV* from,
    VkIndirectCommandsStreamNV* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkIndirectCommandsLayoutTokenNV(
    BumpPool* pool,
    const VkIndirectCommandsLayoutTokenNV* from,
    VkIndirectCommandsLayoutTokenNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pIndexTypes = nullptr;
    if (from->pIndexTypes)
    {
        to->pIndexTypes = (VkIndexType*)pool->dupArray(from->pIndexTypes, from->indexTypeCount * sizeof(const VkIndexType));
    }
    to->pIndexTypeValues = nullptr;
    if (from->pIndexTypeValues)
    {
        to->pIndexTypeValues = (uint32_t*)pool->dupArray(from->pIndexTypeValues, from->indexTypeCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
    BumpPool* pool,
    const VkIndirectCommandsLayoutCreateInfoNV* from,
    VkIndirectCommandsLayoutCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pTokens = nullptr;
        if (from->pTokens)
        {
            to->pTokens = (VkIndirectCommandsLayoutTokenNV*)pool->alloc(from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNV));
            to->tokenCount = from->tokenCount;
            for (uint32_t i = 0; i < (uint32_t)from->tokenCount; ++i)
            {
                deepcopy_VkIndirectCommandsLayoutTokenNV(pool, from->pTokens + i, (VkIndirectCommandsLayoutTokenNV*)(to->pTokens + i));
            }
        }
    }
    to->pStreamStrides = nullptr;
    if (from->pStreamStrides)
    {
        to->pStreamStrides = (uint32_t*)pool->dupArray(from->pStreamStrides, from->streamCount * sizeof(const uint32_t));
    }
}

void deepcopy_VkGeneratedCommandsInfoNV(
    BumpPool* pool,
    const VkGeneratedCommandsInfoNV* from,
    VkGeneratedCommandsInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pStreams = nullptr;
        if (from->pStreams)
        {
            to->pStreams = (VkIndirectCommandsStreamNV*)pool->alloc(from->streamCount * sizeof(const VkIndirectCommandsStreamNV));
            to->streamCount = from->streamCount;
            for (uint32_t i = 0; i < (uint32_t)from->streamCount; ++i)
            {
                deepcopy_VkIndirectCommandsStreamNV(pool, from->pStreams + i, (VkIndirectCommandsStreamNV*)(to->pStreams + i));
            }
        }
    }
}

void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
    BumpPool* pool,
    const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
    VkGeneratedCommandsMemoryRequirementsInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_QCOM_render_pass_transform
void deepcopy_VkRenderPassTransformBeginInfoQCOM(
    BumpPool* pool,
    const VkRenderPassTransformBeginInfoQCOM* from,
    VkRenderPassTransformBeginInfoQCOM* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
    BumpPool* pool,
    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
    VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
}

#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceMemoryReportCallbackDataEXT(
    BumpPool* pool,
    const VkDeviceMemoryReportCallbackDataEXT* from,
    VkDeviceMemoryReportCallbackDataEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
    BumpPool* pool,
    const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
    VkDeviceDeviceMemoryReportCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pUserData = nullptr;
    if (from->pUserData)
    {
        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceRobustness2FeaturesEXT* from,
    VkPhysicalDeviceRobustness2FeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceRobustness2PropertiesEXT* from,
    VkPhysicalDeviceRobustness2PropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
    BumpPool* pool,
    const VkSamplerCustomBorderColorCreateInfoEXT* from,
    VkSamplerCustomBorderColorCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkClearColorValue(pool, &from->customBorderColor, (VkClearColorValue*)(&to->customBorderColor));
}

void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
    VkPhysicalDeviceCustomBorderColorPropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
    VkPhysicalDeviceCustomBorderColorFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDevicePrivateDataFeaturesEXT* from,
    VkPhysicalDevicePrivateDataFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDevicePrivateDataCreateInfoEXT(
    BumpPool* pool,
    const VkDevicePrivateDataCreateInfoEXT* from,
    VkDevicePrivateDataCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPrivateDataSlotCreateInfoEXT(
    BumpPool* pool,
    const VkPrivateDataSlotCreateInfoEXT* from,
    VkPrivateDataSlotCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
    BumpPool* pool,
    const VkDeviceDiagnosticsConfigCreateInfoNV* from,
    VkDeviceDiagnosticsConfigCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
    BumpPool* pool,
    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
    VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_QCOM_rotated_copy_commands
void deepcopy_VkCopyCommandTransformInfoQCOM(
    BumpPool* pool,
    const VkCopyCommandTransformInfoQCOM* from,
    VkCopyCommandTransformInfoQCOM* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_image_robustness
void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
    VkPhysicalDeviceImageRobustnessFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
    BumpPool* pool,
    const VkPhysicalDevice4444FormatsFeaturesEXT* from,
    VkPhysicalDevice4444FormatsFeaturesEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_EXT_directfb_surface
void deepcopy_VkDirectFBSurfaceCreateInfoEXT(
    BumpPool* pool,
    const VkDirectFBSurfaceCreateInfoEXT* from,
    VkDirectFBSurfaceCreateInfoEXT* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->dfb = nullptr;
    if (from->dfb)
    {
        to->dfb = (IDirectFB*)pool->dupArray(from->dfb, sizeof(IDirectFB));
    }
    to->surface = nullptr;
    if (from->surface)
    {
        to->surface = (IDirectFBSurface*)pool->dupArray(from->surface, sizeof(IDirectFBSurface));
    }
}

#endif
#ifdef VK_GOOGLE_gfxstream
#endif
#ifdef VK_KHR_acceleration_structure
void deepcopy_VkDeviceOrHostAddressKHR(
    BumpPool* pool,
    const VkDeviceOrHostAddressKHR* from,
    VkDeviceOrHostAddressKHR* to)
{
    (void)pool;
    *to = *from;
    to->hostAddress = nullptr;
    if (from->hostAddress)
    {
        to->hostAddress = (void*)pool->dupArray(from->hostAddress, sizeof(uint8_t));
    }
}

void deepcopy_VkDeviceOrHostAddressConstKHR(
    BumpPool* pool,
    const VkDeviceOrHostAddressConstKHR* from,
    VkDeviceOrHostAddressConstKHR* to)
{
    (void)pool;
    *to = *from;
    to->hostAddress = nullptr;
    if (from->hostAddress)
    {
        to->hostAddress = (void*)pool->dupArray(from->hostAddress, sizeof(const uint8_t));
    }
}

void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureBuildRangeInfoKHR* from,
    VkAccelerationStructureBuildRangeInfoKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
    BumpPool* pool,
    const VkAccelerationStructureGeometryTrianglesDataKHR* from,
    VkAccelerationStructureGeometryTrianglesDataKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->vertexData, (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->indexData, (VkDeviceOrHostAddressConstKHR*)(&to->indexData));
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->transformData, (VkDeviceOrHostAddressConstKHR*)(&to->transformData));
}

void deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
    BumpPool* pool,
    const VkAccelerationStructureGeometryAabbsDataKHR* from,
    VkAccelerationStructureGeometryAabbsDataKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
}

void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
    BumpPool* pool,
    const VkAccelerationStructureGeometryInstancesDataKHR* from,
    VkAccelerationStructureGeometryInstancesDataKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
}

void deepcopy_VkAccelerationStructureGeometryDataKHR(
    BumpPool* pool,
    const VkAccelerationStructureGeometryDataKHR* from,
    VkAccelerationStructureGeometryDataKHR* to)
{
    (void)pool;
    *to = *from;
    deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(pool, &from->triangles, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&to->triangles));
    deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(pool, &from->aabbs, (VkAccelerationStructureGeometryAabbsDataKHR*)(&to->aabbs));
    deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(pool, &from->instances, (VkAccelerationStructureGeometryInstancesDataKHR*)(&to->instances));
}

void deepcopy_VkAccelerationStructureGeometryKHR(
    BumpPool* pool,
    const VkAccelerationStructureGeometryKHR* from,
    VkAccelerationStructureGeometryKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkAccelerationStructureGeometryDataKHR(pool, &from->geometry, (VkAccelerationStructureGeometryDataKHR*)(&to->geometry));
}

void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureBuildGeometryInfoKHR* from,
    VkAccelerationStructureBuildGeometryInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pGeometries = nullptr;
        if (from->pGeometries)
        {
            to->pGeometries = (VkAccelerationStructureGeometryKHR*)pool->alloc(from->geometryCount * sizeof(const VkAccelerationStructureGeometryKHR));
            to->geometryCount = from->geometryCount;
            for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i)
            {
                deepcopy_VkAccelerationStructureGeometryKHR(pool, from->pGeometries + i, (VkAccelerationStructureGeometryKHR*)(to->pGeometries + i));
            }
        }
    }
    deepcopy_VkDeviceOrHostAddressKHR(pool, &from->scratchData, (VkDeviceOrHostAddressKHR*)(&to->scratchData));
}

void deepcopy_VkAccelerationStructureCreateInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureCreateInfoKHR* from,
    VkAccelerationStructureCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
    BumpPool* pool,
    const VkWriteDescriptorSetAccelerationStructureKHR* from,
    VkWriteDescriptorSetAccelerationStructureKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pAccelerationStructures = nullptr;
    if (from->pAccelerationStructures)
    {
        to->pAccelerationStructures = (VkAccelerationStructureKHR*)pool->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
    }
}

void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
    VkPhysicalDeviceAccelerationStructureFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
    VkPhysicalDeviceAccelerationStructurePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureDeviceAddressInfoKHR* from,
    VkAccelerationStructureDeviceAddressInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAccelerationStructureVersionInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureVersionInfoKHR* from,
    VkAccelerationStructureVersionInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pVersionData = nullptr;
    if (from->pVersionData)
    {
        to->pVersionData = (uint8_t*)pool->dupArray(from->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
    }
}

void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
    BumpPool* pool,
    const VkCopyAccelerationStructureToMemoryInfoKHR* from,
    VkCopyAccelerationStructureToMemoryInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDeviceOrHostAddressKHR(pool, &from->dst, (VkDeviceOrHostAddressKHR*)(&to->dst));
}

void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
    BumpPool* pool,
    const VkCopyMemoryToAccelerationStructureInfoKHR* from,
    VkCopyMemoryToAccelerationStructureInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->src, (VkDeviceOrHostAddressConstKHR*)(&to->src));
}

void deepcopy_VkCopyAccelerationStructureInfoKHR(
    BumpPool* pool,
    const VkCopyAccelerationStructureInfoKHR* from,
    VkCopyAccelerationStructureInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
    BumpPool* pool,
    const VkAccelerationStructureBuildSizesInfoKHR* from,
    VkAccelerationStructureBuildSizesInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
#ifdef VK_KHR_ray_tracing_pipeline
void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
    BumpPool* pool,
    const VkRayTracingShaderGroupCreateInfoKHR* from,
    VkRayTracingShaderGroupCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    to->pShaderGroupCaptureReplayHandle = nullptr;
    if (from->pShaderGroupCaptureReplayHandle)
    {
        to->pShaderGroupCaptureReplayHandle = (void*)pool->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
    }
}

void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
    BumpPool* pool,
    const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
    VkRayTracingPipelineInterfaceCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkRayTracingPipelineCreateInfoKHR(
    BumpPool* pool,
    const VkRayTracingPipelineCreateInfoKHR* from,
    VkRayTracingPipelineCreateInfoKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (const void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
    if (from)
    {
        to->pStages = nullptr;
        if (from->pStages)
        {
            to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
            to->stageCount = from->stageCount;
            for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
            {
                deepcopy_VkPipelineShaderStageCreateInfo(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
            }
        }
    }
    if (from)
    {
        to->pGroups = nullptr;
        if (from->pGroups)
        {
            to->pGroups = (VkRayTracingShaderGroupCreateInfoKHR*)pool->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
            to->groupCount = from->groupCount;
            for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
            {
                deepcopy_VkRayTracingShaderGroupCreateInfoKHR(pool, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
            }
        }
    }
    to->pLibraryInfo = nullptr;
    if (from->pLibraryInfo)
    {
        to->pLibraryInfo = (VkPipelineLibraryCreateInfoKHR*)pool->alloc(sizeof(const VkPipelineLibraryCreateInfoKHR));
        deepcopy_VkPipelineLibraryCreateInfoKHR(pool, from->pLibraryInfo, (VkPipelineLibraryCreateInfoKHR*)(to->pLibraryInfo));
    }
    to->pLibraryInterface = nullptr;
    if (from->pLibraryInterface)
    {
        to->pLibraryInterface = (VkRayTracingPipelineInterfaceCreateInfoKHR*)pool->alloc(sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
        deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(pool, from->pLibraryInterface, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(to->pLibraryInterface));
    }
    to->pDynamicState = nullptr;
    if (from->pDynamicState)
    {
        to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
        deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
    }
}

void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
    VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
    VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

void deepcopy_VkStridedDeviceAddressRegionKHR(
    BumpPool* pool,
    const VkStridedDeviceAddressRegionKHR* from,
    VkStridedDeviceAddressRegionKHR* to)
{
    (void)pool;
    *to = *from;
}

void deepcopy_VkTraceRaysIndirectCommandKHR(
    BumpPool* pool,
    const VkTraceRaysIndirectCommandKHR* from,
    VkTraceRaysIndirectCommandKHR* to)
{
    (void)pool;
    *to = *from;
}

#endif
#ifdef VK_KHR_ray_query
void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
    BumpPool* pool,
    const VkPhysicalDeviceRayQueryFeaturesKHR* from,
    VkPhysicalDeviceRayQueryFeaturesKHR* to)
{
    (void)pool;
    *to = *from;
    const void* from_pNext = from;
    size_t pNext_size = 0u;
    while (!pNext_size && from_pNext)
    {
        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
        pNext_size = goldfish_vk_extension_struct_size(from_pNext);
    }
    to->pNext = nullptr;
    if (pNext_size)
    {
        to->pNext = (void*)pool->alloc(pNext_size);
        deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
    }
}

#endif
void deepcopy_extension_struct(
    BumpPool* pool,
    const void* structExtension,
    void* structExtension_out)
{
    if (!structExtension)
    {
        return;
    }
    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
    switch(structType)
    {
#ifdef VK_VERSION_1_1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceSubgroupProperties(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
        {
            deepcopy_VkPhysicalDevice16BitStorageFeatures(pool, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
        {
            deepcopy_VkMemoryDedicatedRequirements(pool, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
        {
            deepcopy_VkMemoryDedicatedAllocateInfo(pool, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
        {
            deepcopy_VkMemoryAllocateFlagsInfo(pool, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
        {
            deepcopy_VkDeviceGroupRenderPassBeginInfo(pool, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
        {
            deepcopy_VkDeviceGroupCommandBufferBeginInfo(pool, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
        {
            deepcopy_VkDeviceGroupSubmitInfo(pool, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
        {
            deepcopy_VkDeviceGroupBindSparseInfo(pool, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
        {
            deepcopy_VkBindBufferMemoryDeviceGroupInfo(pool, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
        {
            deepcopy_VkBindImageMemoryDeviceGroupInfo(pool, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
        {
            deepcopy_VkDeviceGroupDeviceCreateInfo(pool, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
        {
            deepcopy_VkPhysicalDeviceFeatures2(pool, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
        {
            deepcopy_VkPhysicalDevicePointClippingProperties(pool, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
        {
            deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(pool, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
        {
            deepcopy_VkImageViewUsageCreateInfo(pool, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
        {
            deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(pool, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
        {
            deepcopy_VkRenderPassMultiviewCreateInfo(pool, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
        {
            deepcopy_VkPhysicalDeviceMultiviewFeatures(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceMultiviewProperties(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
        {
            deepcopy_VkPhysicalDeviceVariablePointersFeatures(pool, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
        {
            deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceProtectedMemoryProperties(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
        {
            deepcopy_VkProtectedSubmitInfo(pool, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
        {
            deepcopy_VkSamplerYcbcrConversionInfo(pool, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
        {
            deepcopy_VkBindImagePlaneMemoryInfo(pool, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
        {
            deepcopy_VkImagePlaneMemoryRequirementsInfo(pool, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
        {
            deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(pool, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
        {
            deepcopy_VkSamplerYcbcrConversionImageFormatProperties(pool, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
        {
            deepcopy_VkPhysicalDeviceExternalImageFormatInfo(pool, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
        {
            deepcopy_VkExternalImageFormatProperties(pool, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceIDProperties(pool, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
        {
            deepcopy_VkExternalMemoryImageCreateInfo(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
        {
            deepcopy_VkExternalMemoryBufferCreateInfo(pool, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
        {
            deepcopy_VkExportMemoryAllocateInfo(pool, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
        {
            deepcopy_VkExportFenceCreateInfo(pool, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
        {
            deepcopy_VkExportSemaphoreCreateInfo(pool, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceMaintenance3Properties(pool, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
        {
            deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(pool, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_VERSION_1_2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
        {
            deepcopy_VkPhysicalDeviceVulkan11Features(pool, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceVulkan11Properties(pool, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
        {
            deepcopy_VkPhysicalDeviceVulkan12Features(pool, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceVulkan12Properties(pool, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
        {
            deepcopy_VkImageFormatListCreateInfo(pool, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
        {
            deepcopy_VkPhysicalDevice8BitStorageFeatures(pool, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceDriverProperties(pool, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
        {
            deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(pool, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
        {
            deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(pool, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceFloatControlsProperties(pool, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
        {
            deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(pool, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
        {
            deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
        {
            deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
        {
            deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
        {
            deepcopy_VkSubpassDescriptionDepthStencilResolve(pool, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(pool, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
        {
            deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(pool, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
        {
            deepcopy_VkImageStencilUsageCreateInfo(pool, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
        {
            deepcopy_VkSamplerReductionModeCreateInfo(pool, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(pool, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
        {
            deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(pool, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
        {
            deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(pool, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
        {
            deepcopy_VkFramebufferAttachmentsCreateInfo(pool, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
        {
            deepcopy_VkRenderPassAttachmentBeginInfo(pool, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
        {
            deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(pool, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
        {
            deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(pool, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
        {
            deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(pool, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
        {
            deepcopy_VkAttachmentReferenceStencilLayout(pool, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
        {
            deepcopy_VkAttachmentDescriptionStencilLayout(pool, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
        {
            deepcopy_VkPhysicalDeviceHostQueryResetFeatures(pool, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
        {
            deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(pool, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
        {
            deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(pool, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
        {
            deepcopy_VkSemaphoreTypeCreateInfo(pool, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
        {
            deepcopy_VkTimelineSemaphoreSubmitInfo(pool, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
        {
            deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(pool, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
        {
            deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(pool, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
        {
            deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(pool, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_swapchain
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
        {
            deepcopy_VkImageSwapchainCreateInfoKHR(pool, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
        {
            deepcopy_VkBindImageMemorySwapchainInfoKHR(pool, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
        {
            deepcopy_VkDeviceGroupPresentInfoKHR(pool, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
        {
            deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(pool, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_display_swapchain
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
        {
            deepcopy_VkDisplayPresentInfoKHR(pool, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
        {
            deepcopy_VkImportMemoryWin32HandleInfoKHR(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
        {
            deepcopy_VkExportMemoryWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_fd
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
        {
            deepcopy_VkImportMemoryFdInfoKHR(pool, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
        {
            deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_semaphore_win32
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
        {
            deepcopy_VkExportSemaphoreWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
        {
            deepcopy_VkD3D12FenceSubmitInfoKHR(pool, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_push_descriptor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(pool, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_incremental_present
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
        {
            deepcopy_VkPresentRegionsKHR(pool, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_shared_presentable_image
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
        {
            deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(pool, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_fence_win32
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
        {
            deepcopy_VkExportFenceWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_performance_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(pool, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
        {
            deepcopy_VkQueryPoolPerformanceCreateInfoKHR(pool, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
        {
            deepcopy_VkPerformanceQuerySubmitInfoKHR(pool, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_portability_subset
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(pool, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_shader_clock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_shader_terminate_invocation
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_fragment_shading_rate
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
        {
            deepcopy_VkFragmentShadingRateAttachmentInfoKHR(pool, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
        {
            deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(pool, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_surface_protected_capabilities
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
        {
            deepcopy_VkSurfaceProtectedCapabilitiesKHR(pool, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_ANDROID_native_buffer
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
        {
            deepcopy_VkNativeBufferANDROID(pool, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_debug_report
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
        {
            deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_rasterization_order
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
        {
            deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(pool, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
        {
            deepcopy_VkDedicatedAllocationImageCreateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
        {
            deepcopy_VkDedicatedAllocationBufferCreateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
        {
            deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_transform_feedback
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(pool, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_texture_gather_bias_lod
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
        {
            deepcopy_VkTextureLODGatherFormatPropertiesAMD(pool, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_corner_sampled_image
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_external_memory
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
        {
            deepcopy_VkExternalMemoryImageCreateInfoNV(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
        {
            deepcopy_VkExportMemoryAllocateInfoNV(pool, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
        {
            deepcopy_VkImportMemoryWin32HandleInfoNV(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
        {
            deepcopy_VkExportMemoryWin32HandleInfoNV(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
        {
            deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_flags
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
        {
            deepcopy_VkValidationFlagsEXT(pool, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_astc_decode_mode
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
        {
            deepcopy_VkImageViewASTCDecodeModeEXT(pool, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_conditional_rendering
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
        {
            deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(pool, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_clip_space_w_scaling
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_display_control
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
        {
            deepcopy_VkSwapchainCounterCreateInfoEXT(pool, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_GOOGLE_display_timing
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
        {
            deepcopy_VkPresentTimesInfoGOOGLE(pool, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NVX_multiview_per_view_attributes
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
        {
            deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_viewport_swizzle
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_conservative_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_depth_clip_enable
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_debug_utils
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
        {
            deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
        {
            deepcopy_VkAndroidHardwareBufferUsageANDROID(pool, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
        {
            deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(pool, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
        {
            deepcopy_VkImportAndroidHardwareBufferInfoANDROID(pool, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
        {
            deepcopy_VkExternalFormatANDROID(pool, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_inline_uniform_block
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
        {
            deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(pool, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
        {
            deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(pool, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_sample_locations
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
        {
            deepcopy_VkSampleLocationsInfoEXT(pool, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
        {
            deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(pool, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_blend_operation_advanced
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_fragment_coverage_to_color
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_framebuffer_mixed_samples
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shader_sm_builtins
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_drm_format_modifier
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
        {
            deepcopy_VkDrmFormatModifierPropertiesListEXT(pool, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
        {
            deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(pool, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
        {
            deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(pool, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
        {
            deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(pool, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_cache
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
        {
            deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(pool, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shading_rate_image
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
        {
            deepcopy_VkWriteDescriptorSetAccelerationStructureNV(pool, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_representative_fragment_test
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_filter_cubic
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
        {
            deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(pool, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
        {
            deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(pool, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_global_priority
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
        {
            deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(pool, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_external_memory_host
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
        {
            deepcopy_VkImportMemoryHostPointerInfoEXT(pool, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_pipeline_compiler_control
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
        {
            deepcopy_VkPipelineCompilerControlCreateInfoAMD(pool, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
        {
            deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(pool, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_memory_overallocation_behavior
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
        {
            deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(pool, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_vertex_attribute_divisor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_GGP_frame_token
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
        {
            deepcopy_VkPresentFrameTokenGGP(pool, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_creation_feedback
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(pool, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_compute_shader_derivatives
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_mesh_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_fragment_shader_barycentric
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shader_image_footprint
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_scissor_exclusive
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
        {
            deepcopy_VkQueueFamilyCheckpointPropertiesNV(pool, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_INTEL_shader_integer_functions2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
        {
            deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(pool, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_INTEL_performance_query
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
        {
            deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(pool, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pci_bus_info
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_display_native_hdr
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
        {
            deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(pool, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
        {
            deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(pool, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_GOOGLE_color_buffer
        case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
        {
            deepcopy_VkImportColorBufferGOOGLE(pool, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
        {
            deepcopy_VkImportBufferGOOGLE(pool, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
        {
            deepcopy_VkImportPhysicalAddressGOOGLE(pool, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_subgroup_size_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(pool, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
        {
            deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(pool, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_device_coherent_memory
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
        {
            deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(pool, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_image_atomic_int64
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_memory_budget
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_memory_priority
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
        {
            deepcopy_VkMemoryPriorityAllocateInfoEXT(pool, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_buffer_device_address
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
        {
            deepcopy_VkBufferDeviceAddressCreateInfoEXT(pool, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_features
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
        {
            deepcopy_VkValidationFeaturesEXT(pool, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_cooperative_matrix
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_coverage_reduction_mode
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_fragment_shader_interlock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_ycbcr_image_arrays
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
        {
            deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(pool, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
        {
            deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(pool, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
        {
            deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(pool, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_line_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
        {
            deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_atomic_float
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_index_type_uint8
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_generated_commands
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
        {
            deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(pool, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_texel_buffer_alignment
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_render_pass_transform
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
        {
            deepcopy_VkRenderPassTransformBeginInfoQCOM(pool, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
        {
            deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(pool, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_device_memory_report
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
        {
            deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(pool, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_robustness2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_custom_border_color
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
        {
            deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(pool, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_private_data
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
        {
            deepcopy_VkDevicePrivateDataCreateInfoEXT(pool, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostics_config
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
        {
            deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(pool, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_fragment_shading_rate_enums
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
        {
            deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
        {
            deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
        {
            deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_fragment_density_map2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
        {
            deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_rotated_copy_commands
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
        {
            deepcopy_VkCopyCommandTransformInfoQCOM(pool, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_robustness
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_4444_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
        {
            deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
        {
            deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(pool, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(pool, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
        {
            deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
        {
            deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
        default:
        {
            return;
        }
    }
}


} // namespace goldfish_vk