host/vulkan/cereal/common/goldfish_vk_unbox.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_unbox
// (impl) generated by ../protocols/vk-gen/xml/genvk.py -registry ../protocols/vk-gen/xml/vk.xml cereal -o ../stream-servers/vulkan/cereal
// Please do not modify directly;
// re-run generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR

#include "goldfish_vk_unbox.h"


#include "aemu/base/Pool.h"
#include "goldfish_vk_deepcopy.h"
#include "goldfish_vk_handlemap.h"


namespace goldfish_vk {

#ifdef VK_VERSION_1_0
VkApplicationInfo* unbox_VkApplicationInfo(
    Pool* pool,
    const VkApplicationInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkApplicationInfo* res = (VkApplicationInfo*)pool->alloc(sizeof(const VkApplicationInfo));
    deepcopy_VkApplicationInfo(pool, toUnbox, res);
    handlemap_VkApplicationInfo(&unboxMapping, res);
    return res;
}

VkInstanceCreateInfo* unbox_VkInstanceCreateInfo(
    Pool* pool,
    const VkInstanceCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkInstanceCreateInfo* res = (VkInstanceCreateInfo*)pool->alloc(sizeof(const VkInstanceCreateInfo));
    deepcopy_VkInstanceCreateInfo(pool, toUnbox, res);
    handlemap_VkInstanceCreateInfo(&unboxMapping, res);
    return res;
}

VkAllocationCallbacks* unbox_VkAllocationCallbacks(
    Pool* pool,
    const VkAllocationCallbacks* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAllocationCallbacks* res = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
    deepcopy_VkAllocationCallbacks(pool, toUnbox, res);
    handlemap_VkAllocationCallbacks(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceFeatures* unbox_VkPhysicalDeviceFeatures(
    Pool* pool,
    const VkPhysicalDeviceFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceFeatures* res = (VkPhysicalDeviceFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceFeatures));
    deepcopy_VkPhysicalDeviceFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceFeatures(&unboxMapping, res);
    return res;
}

VkFormatProperties* unbox_VkFormatProperties(
    Pool* pool,
    const VkFormatProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFormatProperties* res = (VkFormatProperties*)pool->alloc(sizeof(const VkFormatProperties));
    deepcopy_VkFormatProperties(pool, toUnbox, res);
    handlemap_VkFormatProperties(&unboxMapping, res);
    return res;
}

VkExtent3D* unbox_VkExtent3D(
    Pool* pool,
    const VkExtent3D* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExtent3D* res = (VkExtent3D*)pool->alloc(sizeof(const VkExtent3D));
    deepcopy_VkExtent3D(pool, toUnbox, res);
    handlemap_VkExtent3D(&unboxMapping, res);
    return res;
}

VkImageFormatProperties* unbox_VkImageFormatProperties(
    Pool* pool,
    const VkImageFormatProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageFormatProperties* res = (VkImageFormatProperties*)pool->alloc(sizeof(const VkImageFormatProperties));
    deepcopy_VkImageFormatProperties(pool, toUnbox, res);
    handlemap_VkImageFormatProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceLimits* unbox_VkPhysicalDeviceLimits(
    Pool* pool,
    const VkPhysicalDeviceLimits* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceLimits* res = (VkPhysicalDeviceLimits*)pool->alloc(sizeof(const VkPhysicalDeviceLimits));
    deepcopy_VkPhysicalDeviceLimits(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceLimits(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceSparseProperties* unbox_VkPhysicalDeviceSparseProperties(
    Pool* pool,
    const VkPhysicalDeviceSparseProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSparseProperties* res = (VkPhysicalDeviceSparseProperties*)pool->alloc(sizeof(const VkPhysicalDeviceSparseProperties));
    deepcopy_VkPhysicalDeviceSparseProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSparseProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceProperties* unbox_VkPhysicalDeviceProperties(
    Pool* pool,
    const VkPhysicalDeviceProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceProperties* res = (VkPhysicalDeviceProperties*)pool->alloc(sizeof(const VkPhysicalDeviceProperties));
    deepcopy_VkPhysicalDeviceProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceProperties(&unboxMapping, res);
    return res;
}

VkQueueFamilyProperties* unbox_VkQueueFamilyProperties(
    Pool* pool,
    const VkQueueFamilyProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkQueueFamilyProperties* res = (VkQueueFamilyProperties*)pool->alloc(sizeof(const VkQueueFamilyProperties));
    deepcopy_VkQueueFamilyProperties(pool, toUnbox, res);
    handlemap_VkQueueFamilyProperties(&unboxMapping, res);
    return res;
}

VkMemoryType* unbox_VkMemoryType(
    Pool* pool,
    const VkMemoryType* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryType* res = (VkMemoryType*)pool->alloc(sizeof(const VkMemoryType));
    deepcopy_VkMemoryType(pool, toUnbox, res);
    handlemap_VkMemoryType(&unboxMapping, res);
    return res;
}

VkMemoryHeap* unbox_VkMemoryHeap(
    Pool* pool,
    const VkMemoryHeap* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryHeap* res = (VkMemoryHeap*)pool->alloc(sizeof(const VkMemoryHeap));
    deepcopy_VkMemoryHeap(pool, toUnbox, res);
    handlemap_VkMemoryHeap(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceMemoryProperties* unbox_VkPhysicalDeviceMemoryProperties(
    Pool* pool,
    const VkPhysicalDeviceMemoryProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMemoryProperties* res = (VkPhysicalDeviceMemoryProperties*)pool->alloc(sizeof(const VkPhysicalDeviceMemoryProperties));
    deepcopy_VkPhysicalDeviceMemoryProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMemoryProperties(&unboxMapping, res);
    return res;
}

VkDeviceQueueCreateInfo* unbox_VkDeviceQueueCreateInfo(
    Pool* pool,
    const VkDeviceQueueCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceQueueCreateInfo* res = (VkDeviceQueueCreateInfo*)pool->alloc(sizeof(const VkDeviceQueueCreateInfo));
    deepcopy_VkDeviceQueueCreateInfo(pool, toUnbox, res);
    handlemap_VkDeviceQueueCreateInfo(&unboxMapping, res);
    return res;
}

VkDeviceCreateInfo* unbox_VkDeviceCreateInfo(
    Pool* pool,
    const VkDeviceCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceCreateInfo* res = (VkDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceCreateInfo));
    deepcopy_VkDeviceCreateInfo(pool, toUnbox, res);
    handlemap_VkDeviceCreateInfo(&unboxMapping, res);
    return res;
}

VkExtensionProperties* unbox_VkExtensionProperties(
    Pool* pool,
    const VkExtensionProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExtensionProperties* res = (VkExtensionProperties*)pool->alloc(sizeof(const VkExtensionProperties));
    deepcopy_VkExtensionProperties(pool, toUnbox, res);
    handlemap_VkExtensionProperties(&unboxMapping, res);
    return res;
}

VkLayerProperties* unbox_VkLayerProperties(
    Pool* pool,
    const VkLayerProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkLayerProperties* res = (VkLayerProperties*)pool->alloc(sizeof(const VkLayerProperties));
    deepcopy_VkLayerProperties(pool, toUnbox, res);
    handlemap_VkLayerProperties(&unboxMapping, res);
    return res;
}

VkSubmitInfo* unbox_VkSubmitInfo(
    Pool* pool,
    const VkSubmitInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubmitInfo* res = (VkSubmitInfo*)pool->alloc(sizeof(const VkSubmitInfo));
    deepcopy_VkSubmitInfo(pool, toUnbox, res);
    handlemap_VkSubmitInfo(&unboxMapping, res);
    return res;
}

VkMemoryAllocateInfo* unbox_VkMemoryAllocateInfo(
    Pool* pool,
    const VkMemoryAllocateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryAllocateInfo* res = (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
    deepcopy_VkMemoryAllocateInfo(pool, toUnbox, res);
    handlemap_VkMemoryAllocateInfo(&unboxMapping, res);
    return res;
}

VkMappedMemoryRange* unbox_VkMappedMemoryRange(
    Pool* pool,
    const VkMappedMemoryRange* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMappedMemoryRange* res = (VkMappedMemoryRange*)pool->alloc(sizeof(const VkMappedMemoryRange));
    deepcopy_VkMappedMemoryRange(pool, toUnbox, res);
    handlemap_VkMappedMemoryRange(&unboxMapping, res);
    return res;
}

VkMemoryRequirements* unbox_VkMemoryRequirements(
    Pool* pool,
    const VkMemoryRequirements* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryRequirements* res = (VkMemoryRequirements*)pool->alloc(sizeof(const VkMemoryRequirements));
    deepcopy_VkMemoryRequirements(pool, toUnbox, res);
    handlemap_VkMemoryRequirements(&unboxMapping, res);
    return res;
}

VkSparseImageFormatProperties* unbox_VkSparseImageFormatProperties(
    Pool* pool,
    const VkSparseImageFormatProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageFormatProperties* res = (VkSparseImageFormatProperties*)pool->alloc(sizeof(const VkSparseImageFormatProperties));
    deepcopy_VkSparseImageFormatProperties(pool, toUnbox, res);
    handlemap_VkSparseImageFormatProperties(&unboxMapping, res);
    return res;
}

VkSparseImageMemoryRequirements* unbox_VkSparseImageMemoryRequirements(
    Pool* pool,
    const VkSparseImageMemoryRequirements* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageMemoryRequirements* res = (VkSparseImageMemoryRequirements*)pool->alloc(sizeof(const VkSparseImageMemoryRequirements));
    deepcopy_VkSparseImageMemoryRequirements(pool, toUnbox, res);
    handlemap_VkSparseImageMemoryRequirements(&unboxMapping, res);
    return res;
}

VkSparseMemoryBind* unbox_VkSparseMemoryBind(
    Pool* pool,
    const VkSparseMemoryBind* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseMemoryBind* res = (VkSparseMemoryBind*)pool->alloc(sizeof(const VkSparseMemoryBind));
    deepcopy_VkSparseMemoryBind(pool, toUnbox, res);
    handlemap_VkSparseMemoryBind(&unboxMapping, res);
    return res;
}

VkSparseBufferMemoryBindInfo* unbox_VkSparseBufferMemoryBindInfo(
    Pool* pool,
    const VkSparseBufferMemoryBindInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseBufferMemoryBindInfo* res = (VkSparseBufferMemoryBindInfo*)pool->alloc(sizeof(const VkSparseBufferMemoryBindInfo));
    deepcopy_VkSparseBufferMemoryBindInfo(pool, toUnbox, res);
    handlemap_VkSparseBufferMemoryBindInfo(&unboxMapping, res);
    return res;
}

VkSparseImageOpaqueMemoryBindInfo* unbox_VkSparseImageOpaqueMemoryBindInfo(
    Pool* pool,
    const VkSparseImageOpaqueMemoryBindInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageOpaqueMemoryBindInfo* res = (VkSparseImageOpaqueMemoryBindInfo*)pool->alloc(sizeof(const VkSparseImageOpaqueMemoryBindInfo));
    deepcopy_VkSparseImageOpaqueMemoryBindInfo(pool, toUnbox, res);
    handlemap_VkSparseImageOpaqueMemoryBindInfo(&unboxMapping, res);
    return res;
}

VkImageSubresource* unbox_VkImageSubresource(
    Pool* pool,
    const VkImageSubresource* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageSubresource* res = (VkImageSubresource*)pool->alloc(sizeof(const VkImageSubresource));
    deepcopy_VkImageSubresource(pool, toUnbox, res);
    handlemap_VkImageSubresource(&unboxMapping, res);
    return res;
}

VkOffset3D* unbox_VkOffset3D(
    Pool* pool,
    const VkOffset3D* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkOffset3D* res = (VkOffset3D*)pool->alloc(sizeof(const VkOffset3D));
    deepcopy_VkOffset3D(pool, toUnbox, res);
    handlemap_VkOffset3D(&unboxMapping, res);
    return res;
}

VkSparseImageMemoryBind* unbox_VkSparseImageMemoryBind(
    Pool* pool,
    const VkSparseImageMemoryBind* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageMemoryBind* res = (VkSparseImageMemoryBind*)pool->alloc(sizeof(const VkSparseImageMemoryBind));
    deepcopy_VkSparseImageMemoryBind(pool, toUnbox, res);
    handlemap_VkSparseImageMemoryBind(&unboxMapping, res);
    return res;
}

VkSparseImageMemoryBindInfo* unbox_VkSparseImageMemoryBindInfo(
    Pool* pool,
    const VkSparseImageMemoryBindInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageMemoryBindInfo* res = (VkSparseImageMemoryBindInfo*)pool->alloc(sizeof(const VkSparseImageMemoryBindInfo));
    deepcopy_VkSparseImageMemoryBindInfo(pool, toUnbox, res);
    handlemap_VkSparseImageMemoryBindInfo(&unboxMapping, res);
    return res;
}

VkBindSparseInfo* unbox_VkBindSparseInfo(
    Pool* pool,
    const VkBindSparseInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindSparseInfo* res = (VkBindSparseInfo*)pool->alloc(sizeof(const VkBindSparseInfo));
    deepcopy_VkBindSparseInfo(pool, toUnbox, res);
    handlemap_VkBindSparseInfo(&unboxMapping, res);
    return res;
}

VkFenceCreateInfo* unbox_VkFenceCreateInfo(
    Pool* pool,
    const VkFenceCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFenceCreateInfo* res = (VkFenceCreateInfo*)pool->alloc(sizeof(const VkFenceCreateInfo));
    deepcopy_VkFenceCreateInfo(pool, toUnbox, res);
    handlemap_VkFenceCreateInfo(&unboxMapping, res);
    return res;
}

VkSemaphoreCreateInfo* unbox_VkSemaphoreCreateInfo(
    Pool* pool,
    const VkSemaphoreCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSemaphoreCreateInfo* res = (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
    deepcopy_VkSemaphoreCreateInfo(pool, toUnbox, res);
    handlemap_VkSemaphoreCreateInfo(&unboxMapping, res);
    return res;
}

VkEventCreateInfo* unbox_VkEventCreateInfo(
    Pool* pool,
    const VkEventCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkEventCreateInfo* res = (VkEventCreateInfo*)pool->alloc(sizeof(const VkEventCreateInfo));
    deepcopy_VkEventCreateInfo(pool, toUnbox, res);
    handlemap_VkEventCreateInfo(&unboxMapping, res);
    return res;
}

VkQueryPoolCreateInfo* unbox_VkQueryPoolCreateInfo(
    Pool* pool,
    const VkQueryPoolCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkQueryPoolCreateInfo* res = (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
    deepcopy_VkQueryPoolCreateInfo(pool, toUnbox, res);
    handlemap_VkQueryPoolCreateInfo(&unboxMapping, res);
    return res;
}

VkBufferCreateInfo* unbox_VkBufferCreateInfo(
    Pool* pool,
    const VkBufferCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferCreateInfo* res = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
    deepcopy_VkBufferCreateInfo(pool, toUnbox, res);
    handlemap_VkBufferCreateInfo(&unboxMapping, res);
    return res;
}

VkBufferViewCreateInfo* unbox_VkBufferViewCreateInfo(
    Pool* pool,
    const VkBufferViewCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferViewCreateInfo* res = (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
    deepcopy_VkBufferViewCreateInfo(pool, toUnbox, res);
    handlemap_VkBufferViewCreateInfo(&unboxMapping, res);
    return res;
}

VkImageCreateInfo* unbox_VkImageCreateInfo(
    Pool* pool,
    const VkImageCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageCreateInfo* res = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
    deepcopy_VkImageCreateInfo(pool, toUnbox, res);
    handlemap_VkImageCreateInfo(&unboxMapping, res);
    return res;
}

VkSubresourceLayout* unbox_VkSubresourceLayout(
    Pool* pool,
    const VkSubresourceLayout* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubresourceLayout* res = (VkSubresourceLayout*)pool->alloc(sizeof(const VkSubresourceLayout));
    deepcopy_VkSubresourceLayout(pool, toUnbox, res);
    handlemap_VkSubresourceLayout(&unboxMapping, res);
    return res;
}

VkComponentMapping* unbox_VkComponentMapping(
    Pool* pool,
    const VkComponentMapping* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkComponentMapping* res = (VkComponentMapping*)pool->alloc(sizeof(const VkComponentMapping));
    deepcopy_VkComponentMapping(pool, toUnbox, res);
    handlemap_VkComponentMapping(&unboxMapping, res);
    return res;
}

VkImageSubresourceRange* unbox_VkImageSubresourceRange(
    Pool* pool,
    const VkImageSubresourceRange* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageSubresourceRange* res = (VkImageSubresourceRange*)pool->alloc(sizeof(const VkImageSubresourceRange));
    deepcopy_VkImageSubresourceRange(pool, toUnbox, res);
    handlemap_VkImageSubresourceRange(&unboxMapping, res);
    return res;
}

VkImageViewCreateInfo* unbox_VkImageViewCreateInfo(
    Pool* pool,
    const VkImageViewCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageViewCreateInfo* res = (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
    deepcopy_VkImageViewCreateInfo(pool, toUnbox, res);
    handlemap_VkImageViewCreateInfo(&unboxMapping, res);
    return res;
}

VkShaderModuleCreateInfo* unbox_VkShaderModuleCreateInfo(
    Pool* pool,
    const VkShaderModuleCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkShaderModuleCreateInfo* res = (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
    deepcopy_VkShaderModuleCreateInfo(pool, toUnbox, res);
    handlemap_VkShaderModuleCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineCacheCreateInfo* unbox_VkPipelineCacheCreateInfo(
    Pool* pool,
    const VkPipelineCacheCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineCacheCreateInfo* res = (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
    deepcopy_VkPipelineCacheCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineCacheCreateInfo(&unboxMapping, res);
    return res;
}

VkSpecializationMapEntry* unbox_VkSpecializationMapEntry(
    Pool* pool,
    const VkSpecializationMapEntry* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSpecializationMapEntry* res = (VkSpecializationMapEntry*)pool->alloc(sizeof(const VkSpecializationMapEntry));
    deepcopy_VkSpecializationMapEntry(pool, toUnbox, res);
    handlemap_VkSpecializationMapEntry(&unboxMapping, res);
    return res;
}

VkSpecializationInfo* unbox_VkSpecializationInfo(
    Pool* pool,
    const VkSpecializationInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSpecializationInfo* res = (VkSpecializationInfo*)pool->alloc(sizeof(const VkSpecializationInfo));
    deepcopy_VkSpecializationInfo(pool, toUnbox, res);
    handlemap_VkSpecializationInfo(&unboxMapping, res);
    return res;
}

VkPipelineShaderStageCreateInfo* unbox_VkPipelineShaderStageCreateInfo(
    Pool* pool,
    const VkPipelineShaderStageCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineShaderStageCreateInfo* res = (VkPipelineShaderStageCreateInfo*)pool->alloc(sizeof(const VkPipelineShaderStageCreateInfo));
    deepcopy_VkPipelineShaderStageCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineShaderStageCreateInfo(&unboxMapping, res);
    return res;
}

VkVertexInputBindingDescription* unbox_VkVertexInputBindingDescription(
    Pool* pool,
    const VkVertexInputBindingDescription* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkVertexInputBindingDescription* res = (VkVertexInputBindingDescription*)pool->alloc(sizeof(const VkVertexInputBindingDescription));
    deepcopy_VkVertexInputBindingDescription(pool, toUnbox, res);
    handlemap_VkVertexInputBindingDescription(&unboxMapping, res);
    return res;
}

VkVertexInputAttributeDescription* unbox_VkVertexInputAttributeDescription(
    Pool* pool,
    const VkVertexInputAttributeDescription* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkVertexInputAttributeDescription* res = (VkVertexInputAttributeDescription*)pool->alloc(sizeof(const VkVertexInputAttributeDescription));
    deepcopy_VkVertexInputAttributeDescription(pool, toUnbox, res);
    handlemap_VkVertexInputAttributeDescription(&unboxMapping, res);
    return res;
}

VkPipelineVertexInputStateCreateInfo* unbox_VkPipelineVertexInputStateCreateInfo(
    Pool* pool,
    const VkPipelineVertexInputStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineVertexInputStateCreateInfo* res = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
    deepcopy_VkPipelineVertexInputStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineVertexInputStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineInputAssemblyStateCreateInfo* unbox_VkPipelineInputAssemblyStateCreateInfo(
    Pool* pool,
    const VkPipelineInputAssemblyStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineInputAssemblyStateCreateInfo* res = (VkPipelineInputAssemblyStateCreateInfo*)pool->alloc(sizeof(const VkPipelineInputAssemblyStateCreateInfo));
    deepcopy_VkPipelineInputAssemblyStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineInputAssemblyStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineTessellationStateCreateInfo* unbox_VkPipelineTessellationStateCreateInfo(
    Pool* pool,
    const VkPipelineTessellationStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineTessellationStateCreateInfo* res = (VkPipelineTessellationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
    deepcopy_VkPipelineTessellationStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineTessellationStateCreateInfo(&unboxMapping, res);
    return res;
}

VkViewport* unbox_VkViewport(
    Pool* pool,
    const VkViewport* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkViewport* res = (VkViewport*)pool->alloc(sizeof(const VkViewport));
    deepcopy_VkViewport(pool, toUnbox, res);
    handlemap_VkViewport(&unboxMapping, res);
    return res;
}

VkOffset2D* unbox_VkOffset2D(
    Pool* pool,
    const VkOffset2D* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkOffset2D* res = (VkOffset2D*)pool->alloc(sizeof(const VkOffset2D));
    deepcopy_VkOffset2D(pool, toUnbox, res);
    handlemap_VkOffset2D(&unboxMapping, res);
    return res;
}

VkExtent2D* unbox_VkExtent2D(
    Pool* pool,
    const VkExtent2D* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExtent2D* res = (VkExtent2D*)pool->alloc(sizeof(const VkExtent2D));
    deepcopy_VkExtent2D(pool, toUnbox, res);
    handlemap_VkExtent2D(&unboxMapping, res);
    return res;
}

VkRect2D* unbox_VkRect2D(
    Pool* pool,
    const VkRect2D* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRect2D* res = (VkRect2D*)pool->alloc(sizeof(const VkRect2D));
    deepcopy_VkRect2D(pool, toUnbox, res);
    handlemap_VkRect2D(&unboxMapping, res);
    return res;
}

VkPipelineViewportStateCreateInfo* unbox_VkPipelineViewportStateCreateInfo(
    Pool* pool,
    const VkPipelineViewportStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineViewportStateCreateInfo* res = (VkPipelineViewportStateCreateInfo*)pool->alloc(sizeof(const VkPipelineViewportStateCreateInfo));
    deepcopy_VkPipelineViewportStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineViewportStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineRasterizationStateCreateInfo* unbox_VkPipelineRasterizationStateCreateInfo(
    Pool* pool,
    const VkPipelineRasterizationStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineRasterizationStateCreateInfo* res = (VkPipelineRasterizationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
    deepcopy_VkPipelineRasterizationStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineRasterizationStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineMultisampleStateCreateInfo* unbox_VkPipelineMultisampleStateCreateInfo(
    Pool* pool,
    const VkPipelineMultisampleStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineMultisampleStateCreateInfo* res = (VkPipelineMultisampleStateCreateInfo*)pool->alloc(sizeof(const VkPipelineMultisampleStateCreateInfo));
    deepcopy_VkPipelineMultisampleStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineMultisampleStateCreateInfo(&unboxMapping, res);
    return res;
}

VkStencilOpState* unbox_VkStencilOpState(
    Pool* pool,
    const VkStencilOpState* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkStencilOpState* res = (VkStencilOpState*)pool->alloc(sizeof(const VkStencilOpState));
    deepcopy_VkStencilOpState(pool, toUnbox, res);
    handlemap_VkStencilOpState(&unboxMapping, res);
    return res;
}

VkPipelineDepthStencilStateCreateInfo* unbox_VkPipelineDepthStencilStateCreateInfo(
    Pool* pool,
    const VkPipelineDepthStencilStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineDepthStencilStateCreateInfo* res = (VkPipelineDepthStencilStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
    deepcopy_VkPipelineDepthStencilStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineDepthStencilStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineColorBlendAttachmentState* unbox_VkPipelineColorBlendAttachmentState(
    Pool* pool,
    const VkPipelineColorBlendAttachmentState* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineColorBlendAttachmentState* res = (VkPipelineColorBlendAttachmentState*)pool->alloc(sizeof(const VkPipelineColorBlendAttachmentState));
    deepcopy_VkPipelineColorBlendAttachmentState(pool, toUnbox, res);
    handlemap_VkPipelineColorBlendAttachmentState(&unboxMapping, res);
    return res;
}

VkPipelineColorBlendStateCreateInfo* unbox_VkPipelineColorBlendStateCreateInfo(
    Pool* pool,
    const VkPipelineColorBlendStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineColorBlendStateCreateInfo* res = (VkPipelineColorBlendStateCreateInfo*)pool->alloc(sizeof(const VkPipelineColorBlendStateCreateInfo));
    deepcopy_VkPipelineColorBlendStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineColorBlendStateCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineDynamicStateCreateInfo* unbox_VkPipelineDynamicStateCreateInfo(
    Pool* pool,
    const VkPipelineDynamicStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineDynamicStateCreateInfo* res = (VkPipelineDynamicStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
    deepcopy_VkPipelineDynamicStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineDynamicStateCreateInfo(&unboxMapping, res);
    return res;
}

VkGraphicsPipelineCreateInfo* unbox_VkGraphicsPipelineCreateInfo(
    Pool* pool,
    const VkGraphicsPipelineCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkGraphicsPipelineCreateInfo* res = (VkGraphicsPipelineCreateInfo*)pool->alloc(sizeof(const VkGraphicsPipelineCreateInfo));
    deepcopy_VkGraphicsPipelineCreateInfo(pool, toUnbox, res);
    handlemap_VkGraphicsPipelineCreateInfo(&unboxMapping, res);
    return res;
}

VkComputePipelineCreateInfo* unbox_VkComputePipelineCreateInfo(
    Pool* pool,
    const VkComputePipelineCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkComputePipelineCreateInfo* res = (VkComputePipelineCreateInfo*)pool->alloc(sizeof(const VkComputePipelineCreateInfo));
    deepcopy_VkComputePipelineCreateInfo(pool, toUnbox, res);
    handlemap_VkComputePipelineCreateInfo(&unboxMapping, res);
    return res;
}

VkPushConstantRange* unbox_VkPushConstantRange(
    Pool* pool,
    const VkPushConstantRange* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPushConstantRange* res = (VkPushConstantRange*)pool->alloc(sizeof(const VkPushConstantRange));
    deepcopy_VkPushConstantRange(pool, toUnbox, res);
    handlemap_VkPushConstantRange(&unboxMapping, res);
    return res;
}

VkPipelineLayoutCreateInfo* unbox_VkPipelineLayoutCreateInfo(
    Pool* pool,
    const VkPipelineLayoutCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineLayoutCreateInfo* res = (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
    deepcopy_VkPipelineLayoutCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineLayoutCreateInfo(&unboxMapping, res);
    return res;
}

VkSamplerCreateInfo* unbox_VkSamplerCreateInfo(
    Pool* pool,
    const VkSamplerCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSamplerCreateInfo* res = (VkSamplerCreateInfo*)pool->alloc(sizeof(const VkSamplerCreateInfo));
    deepcopy_VkSamplerCreateInfo(pool, toUnbox, res);
    handlemap_VkSamplerCreateInfo(&unboxMapping, res);
    return res;
}

VkDescriptorSetLayoutBinding* unbox_VkDescriptorSetLayoutBinding(
    Pool* pool,
    const VkDescriptorSetLayoutBinding* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetLayoutBinding* res = (VkDescriptorSetLayoutBinding*)pool->alloc(sizeof(const VkDescriptorSetLayoutBinding));
    deepcopy_VkDescriptorSetLayoutBinding(pool, toUnbox, res);
    handlemap_VkDescriptorSetLayoutBinding(&unboxMapping, res);
    return res;
}

VkDescriptorSetLayoutCreateInfo* unbox_VkDescriptorSetLayoutCreateInfo(
    Pool* pool,
    const VkDescriptorSetLayoutCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetLayoutCreateInfo* res = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
    deepcopy_VkDescriptorSetLayoutCreateInfo(pool, toUnbox, res);
    handlemap_VkDescriptorSetLayoutCreateInfo(&unboxMapping, res);
    return res;
}

VkDescriptorPoolSize* unbox_VkDescriptorPoolSize(
    Pool* pool,
    const VkDescriptorPoolSize* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorPoolSize* res = (VkDescriptorPoolSize*)pool->alloc(sizeof(const VkDescriptorPoolSize));
    deepcopy_VkDescriptorPoolSize(pool, toUnbox, res);
    handlemap_VkDescriptorPoolSize(&unboxMapping, res);
    return res;
}

VkDescriptorPoolCreateInfo* unbox_VkDescriptorPoolCreateInfo(
    Pool* pool,
    const VkDescriptorPoolCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorPoolCreateInfo* res = (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
    deepcopy_VkDescriptorPoolCreateInfo(pool, toUnbox, res);
    handlemap_VkDescriptorPoolCreateInfo(&unboxMapping, res);
    return res;
}

VkDescriptorSetAllocateInfo* unbox_VkDescriptorSetAllocateInfo(
    Pool* pool,
    const VkDescriptorSetAllocateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetAllocateInfo* res = (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
    deepcopy_VkDescriptorSetAllocateInfo(pool, toUnbox, res);
    handlemap_VkDescriptorSetAllocateInfo(&unboxMapping, res);
    return res;
}

VkDescriptorImageInfo* unbox_VkDescriptorImageInfo(
    Pool* pool,
    const VkDescriptorImageInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorImageInfo* res = (VkDescriptorImageInfo*)pool->alloc(sizeof(const VkDescriptorImageInfo));
    deepcopy_VkDescriptorImageInfo(pool, toUnbox, res);
    handlemap_VkDescriptorImageInfo(&unboxMapping, res);
    return res;
}

VkDescriptorBufferInfo* unbox_VkDescriptorBufferInfo(
    Pool* pool,
    const VkDescriptorBufferInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorBufferInfo* res = (VkDescriptorBufferInfo*)pool->alloc(sizeof(const VkDescriptorBufferInfo));
    deepcopy_VkDescriptorBufferInfo(pool, toUnbox, res);
    handlemap_VkDescriptorBufferInfo(&unboxMapping, res);
    return res;
}

VkWriteDescriptorSet* unbox_VkWriteDescriptorSet(
    Pool* pool,
    const VkWriteDescriptorSet* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkWriteDescriptorSet* res = (VkWriteDescriptorSet*)pool->alloc(sizeof(const VkWriteDescriptorSet));
    deepcopy_VkWriteDescriptorSet(pool, toUnbox, res);
    handlemap_VkWriteDescriptorSet(&unboxMapping, res);
    return res;
}

VkCopyDescriptorSet* unbox_VkCopyDescriptorSet(
    Pool* pool,
    const VkCopyDescriptorSet* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCopyDescriptorSet* res = (VkCopyDescriptorSet*)pool->alloc(sizeof(const VkCopyDescriptorSet));
    deepcopy_VkCopyDescriptorSet(pool, toUnbox, res);
    handlemap_VkCopyDescriptorSet(&unboxMapping, res);
    return res;
}

VkFramebufferCreateInfo* unbox_VkFramebufferCreateInfo(
    Pool* pool,
    const VkFramebufferCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFramebufferCreateInfo* res = (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
    deepcopy_VkFramebufferCreateInfo(pool, toUnbox, res);
    handlemap_VkFramebufferCreateInfo(&unboxMapping, res);
    return res;
}

VkAttachmentDescription* unbox_VkAttachmentDescription(
    Pool* pool,
    const VkAttachmentDescription* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAttachmentDescription* res = (VkAttachmentDescription*)pool->alloc(sizeof(const VkAttachmentDescription));
    deepcopy_VkAttachmentDescription(pool, toUnbox, res);
    handlemap_VkAttachmentDescription(&unboxMapping, res);
    return res;
}

VkAttachmentReference* unbox_VkAttachmentReference(
    Pool* pool,
    const VkAttachmentReference* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAttachmentReference* res = (VkAttachmentReference*)pool->alloc(sizeof(const VkAttachmentReference));
    deepcopy_VkAttachmentReference(pool, toUnbox, res);
    handlemap_VkAttachmentReference(&unboxMapping, res);
    return res;
}

VkSubpassDescription* unbox_VkSubpassDescription(
    Pool* pool,
    const VkSubpassDescription* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassDescription* res = (VkSubpassDescription*)pool->alloc(sizeof(const VkSubpassDescription));
    deepcopy_VkSubpassDescription(pool, toUnbox, res);
    handlemap_VkSubpassDescription(&unboxMapping, res);
    return res;
}

VkSubpassDependency* unbox_VkSubpassDependency(
    Pool* pool,
    const VkSubpassDependency* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassDependency* res = (VkSubpassDependency*)pool->alloc(sizeof(const VkSubpassDependency));
    deepcopy_VkSubpassDependency(pool, toUnbox, res);
    handlemap_VkSubpassDependency(&unboxMapping, res);
    return res;
}

VkRenderPassCreateInfo* unbox_VkRenderPassCreateInfo(
    Pool* pool,
    const VkRenderPassCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassCreateInfo* res = (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
    deepcopy_VkRenderPassCreateInfo(pool, toUnbox, res);
    handlemap_VkRenderPassCreateInfo(&unboxMapping, res);
    return res;
}

VkCommandPoolCreateInfo* unbox_VkCommandPoolCreateInfo(
    Pool* pool,
    const VkCommandPoolCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCommandPoolCreateInfo* res = (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
    deepcopy_VkCommandPoolCreateInfo(pool, toUnbox, res);
    handlemap_VkCommandPoolCreateInfo(&unboxMapping, res);
    return res;
}

VkCommandBufferAllocateInfo* unbox_VkCommandBufferAllocateInfo(
    Pool* pool,
    const VkCommandBufferAllocateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCommandBufferAllocateInfo* res = (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
    deepcopy_VkCommandBufferAllocateInfo(pool, toUnbox, res);
    handlemap_VkCommandBufferAllocateInfo(&unboxMapping, res);
    return res;
}

VkCommandBufferInheritanceInfo* unbox_VkCommandBufferInheritanceInfo(
    Pool* pool,
    const VkCommandBufferInheritanceInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCommandBufferInheritanceInfo* res = (VkCommandBufferInheritanceInfo*)pool->alloc(sizeof(const VkCommandBufferInheritanceInfo));
    deepcopy_VkCommandBufferInheritanceInfo(pool, toUnbox, res);
    handlemap_VkCommandBufferInheritanceInfo(&unboxMapping, res);
    return res;
}

VkCommandBufferBeginInfo* unbox_VkCommandBufferBeginInfo(
    Pool* pool,
    const VkCommandBufferBeginInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCommandBufferBeginInfo* res = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
    deepcopy_VkCommandBufferBeginInfo(pool, toUnbox, res);
    handlemap_VkCommandBufferBeginInfo(&unboxMapping, res);
    return res;
}

VkBufferCopy* unbox_VkBufferCopy(
    Pool* pool,
    const VkBufferCopy* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferCopy* res = (VkBufferCopy*)pool->alloc(sizeof(const VkBufferCopy));
    deepcopy_VkBufferCopy(pool, toUnbox, res);
    handlemap_VkBufferCopy(&unboxMapping, res);
    return res;
}

VkImageSubresourceLayers* unbox_VkImageSubresourceLayers(
    Pool* pool,
    const VkImageSubresourceLayers* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageSubresourceLayers* res = (VkImageSubresourceLayers*)pool->alloc(sizeof(const VkImageSubresourceLayers));
    deepcopy_VkImageSubresourceLayers(pool, toUnbox, res);
    handlemap_VkImageSubresourceLayers(&unboxMapping, res);
    return res;
}

VkImageCopy* unbox_VkImageCopy(
    Pool* pool,
    const VkImageCopy* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageCopy* res = (VkImageCopy*)pool->alloc(sizeof(const VkImageCopy));
    deepcopy_VkImageCopy(pool, toUnbox, res);
    handlemap_VkImageCopy(&unboxMapping, res);
    return res;
}

VkImageBlit* unbox_VkImageBlit(
    Pool* pool,
    const VkImageBlit* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageBlit* res = (VkImageBlit*)pool->alloc(sizeof(const VkImageBlit));
    deepcopy_VkImageBlit(pool, toUnbox, res);
    handlemap_VkImageBlit(&unboxMapping, res);
    return res;
}

VkBufferImageCopy* unbox_VkBufferImageCopy(
    Pool* pool,
    const VkBufferImageCopy* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferImageCopy* res = (VkBufferImageCopy*)pool->alloc(sizeof(const VkBufferImageCopy));
    deepcopy_VkBufferImageCopy(pool, toUnbox, res);
    handlemap_VkBufferImageCopy(&unboxMapping, res);
    return res;
}

VkClearColorValue* unbox_VkClearColorValue(
    Pool* pool,
    const VkClearColorValue* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkClearColorValue* res = (VkClearColorValue*)pool->alloc(sizeof(const VkClearColorValue));
    deepcopy_VkClearColorValue(pool, toUnbox, res);
    handlemap_VkClearColorValue(&unboxMapping, res);
    return res;
}

VkClearDepthStencilValue* unbox_VkClearDepthStencilValue(
    Pool* pool,
    const VkClearDepthStencilValue* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkClearDepthStencilValue* res = (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
    deepcopy_VkClearDepthStencilValue(pool, toUnbox, res);
    handlemap_VkClearDepthStencilValue(&unboxMapping, res);
    return res;
}

VkClearValue* unbox_VkClearValue(
    Pool* pool,
    const VkClearValue* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkClearValue* res = (VkClearValue*)pool->alloc(sizeof(const VkClearValue));
    deepcopy_VkClearValue(pool, toUnbox, res);
    handlemap_VkClearValue(&unboxMapping, res);
    return res;
}

VkClearAttachment* unbox_VkClearAttachment(
    Pool* pool,
    const VkClearAttachment* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkClearAttachment* res = (VkClearAttachment*)pool->alloc(sizeof(const VkClearAttachment));
    deepcopy_VkClearAttachment(pool, toUnbox, res);
    handlemap_VkClearAttachment(&unboxMapping, res);
    return res;
}

VkClearRect* unbox_VkClearRect(
    Pool* pool,
    const VkClearRect* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkClearRect* res = (VkClearRect*)pool->alloc(sizeof(const VkClearRect));
    deepcopy_VkClearRect(pool, toUnbox, res);
    handlemap_VkClearRect(&unboxMapping, res);
    return res;
}

VkImageResolve* unbox_VkImageResolve(
    Pool* pool,
    const VkImageResolve* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageResolve* res = (VkImageResolve*)pool->alloc(sizeof(const VkImageResolve));
    deepcopy_VkImageResolve(pool, toUnbox, res);
    handlemap_VkImageResolve(&unboxMapping, res);
    return res;
}

VkMemoryBarrier* unbox_VkMemoryBarrier(
    Pool* pool,
    const VkMemoryBarrier* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryBarrier* res = (VkMemoryBarrier*)pool->alloc(sizeof(const VkMemoryBarrier));
    deepcopy_VkMemoryBarrier(pool, toUnbox, res);
    handlemap_VkMemoryBarrier(&unboxMapping, res);
    return res;
}

VkBufferMemoryBarrier* unbox_VkBufferMemoryBarrier(
    Pool* pool,
    const VkBufferMemoryBarrier* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferMemoryBarrier* res = (VkBufferMemoryBarrier*)pool->alloc(sizeof(const VkBufferMemoryBarrier));
    deepcopy_VkBufferMemoryBarrier(pool, toUnbox, res);
    handlemap_VkBufferMemoryBarrier(&unboxMapping, res);
    return res;
}

VkImageMemoryBarrier* unbox_VkImageMemoryBarrier(
    Pool* pool,
    const VkImageMemoryBarrier* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageMemoryBarrier* res = (VkImageMemoryBarrier*)pool->alloc(sizeof(const VkImageMemoryBarrier));
    deepcopy_VkImageMemoryBarrier(pool, toUnbox, res);
    handlemap_VkImageMemoryBarrier(&unboxMapping, res);
    return res;
}

VkRenderPassBeginInfo* unbox_VkRenderPassBeginInfo(
    Pool* pool,
    const VkRenderPassBeginInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassBeginInfo* res = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
    deepcopy_VkRenderPassBeginInfo(pool, toUnbox, res);
    handlemap_VkRenderPassBeginInfo(&unboxMapping, res);
    return res;
}

VkDispatchIndirectCommand* unbox_VkDispatchIndirectCommand(
    Pool* pool,
    const VkDispatchIndirectCommand* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDispatchIndirectCommand* res = (VkDispatchIndirectCommand*)pool->alloc(sizeof(const VkDispatchIndirectCommand));
    deepcopy_VkDispatchIndirectCommand(pool, toUnbox, res);
    handlemap_VkDispatchIndirectCommand(&unboxMapping, res);
    return res;
}

VkDrawIndexedIndirectCommand* unbox_VkDrawIndexedIndirectCommand(
    Pool* pool,
    const VkDrawIndexedIndirectCommand* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDrawIndexedIndirectCommand* res = (VkDrawIndexedIndirectCommand*)pool->alloc(sizeof(const VkDrawIndexedIndirectCommand));
    deepcopy_VkDrawIndexedIndirectCommand(pool, toUnbox, res);
    handlemap_VkDrawIndexedIndirectCommand(&unboxMapping, res);
    return res;
}

VkDrawIndirectCommand* unbox_VkDrawIndirectCommand(
    Pool* pool,
    const VkDrawIndirectCommand* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDrawIndirectCommand* res = (VkDrawIndirectCommand*)pool->alloc(sizeof(const VkDrawIndirectCommand));
    deepcopy_VkDrawIndirectCommand(pool, toUnbox, res);
    handlemap_VkDrawIndirectCommand(&unboxMapping, res);
    return res;
}

VkBaseOutStructure* unbox_VkBaseOutStructure(
    Pool* pool,
    const VkBaseOutStructure* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBaseOutStructure* res = (VkBaseOutStructure*)pool->alloc(sizeof(const VkBaseOutStructure));
    deepcopy_VkBaseOutStructure(pool, toUnbox, res);
    handlemap_VkBaseOutStructure(&unboxMapping, res);
    return res;
}

VkBaseInStructure* unbox_VkBaseInStructure(
    Pool* pool,
    const VkBaseInStructure* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBaseInStructure* res = (VkBaseInStructure*)pool->alloc(sizeof(const VkBaseInStructure));
    deepcopy_VkBaseInStructure(pool, toUnbox, res);
    handlemap_VkBaseInStructure(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_VERSION_1_1
VkPhysicalDeviceSubgroupProperties* unbox_VkPhysicalDeviceSubgroupProperties(
    Pool* pool,
    const VkPhysicalDeviceSubgroupProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSubgroupProperties* res = (VkPhysicalDeviceSubgroupProperties*)pool->alloc(sizeof(const VkPhysicalDeviceSubgroupProperties));
    deepcopy_VkPhysicalDeviceSubgroupProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSubgroupProperties(&unboxMapping, res);
    return res;
}

VkBindBufferMemoryInfo* unbox_VkBindBufferMemoryInfo(
    Pool* pool,
    const VkBindBufferMemoryInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindBufferMemoryInfo* res = (VkBindBufferMemoryInfo*)pool->alloc(sizeof(const VkBindBufferMemoryInfo));
    deepcopy_VkBindBufferMemoryInfo(pool, toUnbox, res);
    handlemap_VkBindBufferMemoryInfo(&unboxMapping, res);
    return res;
}

VkBindImageMemoryInfo* unbox_VkBindImageMemoryInfo(
    Pool* pool,
    const VkBindImageMemoryInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindImageMemoryInfo* res = (VkBindImageMemoryInfo*)pool->alloc(sizeof(const VkBindImageMemoryInfo));
    deepcopy_VkBindImageMemoryInfo(pool, toUnbox, res);
    handlemap_VkBindImageMemoryInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDevice16BitStorageFeatures* unbox_VkPhysicalDevice16BitStorageFeatures(
    Pool* pool,
    const VkPhysicalDevice16BitStorageFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDevice16BitStorageFeatures* res = (VkPhysicalDevice16BitStorageFeatures*)pool->alloc(sizeof(const VkPhysicalDevice16BitStorageFeatures));
    deepcopy_VkPhysicalDevice16BitStorageFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDevice16BitStorageFeatures(&unboxMapping, res);
    return res;
}

VkMemoryDedicatedRequirements* unbox_VkMemoryDedicatedRequirements(
    Pool* pool,
    const VkMemoryDedicatedRequirements* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryDedicatedRequirements* res = (VkMemoryDedicatedRequirements*)pool->alloc(sizeof(const VkMemoryDedicatedRequirements));
    deepcopy_VkMemoryDedicatedRequirements(pool, toUnbox, res);
    handlemap_VkMemoryDedicatedRequirements(&unboxMapping, res);
    return res;
}

VkMemoryDedicatedAllocateInfo* unbox_VkMemoryDedicatedAllocateInfo(
    Pool* pool,
    const VkMemoryDedicatedAllocateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryDedicatedAllocateInfo* res = (VkMemoryDedicatedAllocateInfo*)pool->alloc(sizeof(const VkMemoryDedicatedAllocateInfo));
    deepcopy_VkMemoryDedicatedAllocateInfo(pool, toUnbox, res);
    handlemap_VkMemoryDedicatedAllocateInfo(&unboxMapping, res);
    return res;
}

VkMemoryAllocateFlagsInfo* unbox_VkMemoryAllocateFlagsInfo(
    Pool* pool,
    const VkMemoryAllocateFlagsInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryAllocateFlagsInfo* res = (VkMemoryAllocateFlagsInfo*)pool->alloc(sizeof(const VkMemoryAllocateFlagsInfo));
    deepcopy_VkMemoryAllocateFlagsInfo(pool, toUnbox, res);
    handlemap_VkMemoryAllocateFlagsInfo(&unboxMapping, res);
    return res;
}

VkDeviceGroupRenderPassBeginInfo* unbox_VkDeviceGroupRenderPassBeginInfo(
    Pool* pool,
    const VkDeviceGroupRenderPassBeginInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupRenderPassBeginInfo* res = (VkDeviceGroupRenderPassBeginInfo*)pool->alloc(sizeof(const VkDeviceGroupRenderPassBeginInfo));
    deepcopy_VkDeviceGroupRenderPassBeginInfo(pool, toUnbox, res);
    handlemap_VkDeviceGroupRenderPassBeginInfo(&unboxMapping, res);
    return res;
}

VkDeviceGroupCommandBufferBeginInfo* unbox_VkDeviceGroupCommandBufferBeginInfo(
    Pool* pool,
    const VkDeviceGroupCommandBufferBeginInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupCommandBufferBeginInfo* res = (VkDeviceGroupCommandBufferBeginInfo*)pool->alloc(sizeof(const VkDeviceGroupCommandBufferBeginInfo));
    deepcopy_VkDeviceGroupCommandBufferBeginInfo(pool, toUnbox, res);
    handlemap_VkDeviceGroupCommandBufferBeginInfo(&unboxMapping, res);
    return res;
}

VkDeviceGroupSubmitInfo* unbox_VkDeviceGroupSubmitInfo(
    Pool* pool,
    const VkDeviceGroupSubmitInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupSubmitInfo* res = (VkDeviceGroupSubmitInfo*)pool->alloc(sizeof(const VkDeviceGroupSubmitInfo));
    deepcopy_VkDeviceGroupSubmitInfo(pool, toUnbox, res);
    handlemap_VkDeviceGroupSubmitInfo(&unboxMapping, res);
    return res;
}

VkDeviceGroupBindSparseInfo* unbox_VkDeviceGroupBindSparseInfo(
    Pool* pool,
    const VkDeviceGroupBindSparseInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupBindSparseInfo* res = (VkDeviceGroupBindSparseInfo*)pool->alloc(sizeof(const VkDeviceGroupBindSparseInfo));
    deepcopy_VkDeviceGroupBindSparseInfo(pool, toUnbox, res);
    handlemap_VkDeviceGroupBindSparseInfo(&unboxMapping, res);
    return res;
}

VkBindBufferMemoryDeviceGroupInfo* unbox_VkBindBufferMemoryDeviceGroupInfo(
    Pool* pool,
    const VkBindBufferMemoryDeviceGroupInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindBufferMemoryDeviceGroupInfo* res = (VkBindBufferMemoryDeviceGroupInfo*)pool->alloc(sizeof(const VkBindBufferMemoryDeviceGroupInfo));
    deepcopy_VkBindBufferMemoryDeviceGroupInfo(pool, toUnbox, res);
    handlemap_VkBindBufferMemoryDeviceGroupInfo(&unboxMapping, res);
    return res;
}

VkBindImageMemoryDeviceGroupInfo* unbox_VkBindImageMemoryDeviceGroupInfo(
    Pool* pool,
    const VkBindImageMemoryDeviceGroupInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindImageMemoryDeviceGroupInfo* res = (VkBindImageMemoryDeviceGroupInfo*)pool->alloc(sizeof(const VkBindImageMemoryDeviceGroupInfo));
    deepcopy_VkBindImageMemoryDeviceGroupInfo(pool, toUnbox, res);
    handlemap_VkBindImageMemoryDeviceGroupInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceGroupProperties* unbox_VkPhysicalDeviceGroupProperties(
    Pool* pool,
    const VkPhysicalDeviceGroupProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceGroupProperties* res = (VkPhysicalDeviceGroupProperties*)pool->alloc(sizeof(const VkPhysicalDeviceGroupProperties));
    deepcopy_VkPhysicalDeviceGroupProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceGroupProperties(&unboxMapping, res);
    return res;
}

VkDeviceGroupDeviceCreateInfo* unbox_VkDeviceGroupDeviceCreateInfo(
    Pool* pool,
    const VkDeviceGroupDeviceCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupDeviceCreateInfo* res = (VkDeviceGroupDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceGroupDeviceCreateInfo));
    deepcopy_VkDeviceGroupDeviceCreateInfo(pool, toUnbox, res);
    handlemap_VkDeviceGroupDeviceCreateInfo(&unboxMapping, res);
    return res;
}

VkBufferMemoryRequirementsInfo2* unbox_VkBufferMemoryRequirementsInfo2(
    Pool* pool,
    const VkBufferMemoryRequirementsInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBufferMemoryRequirementsInfo2* res = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
    deepcopy_VkBufferMemoryRequirementsInfo2(pool, toUnbox, res);
    handlemap_VkBufferMemoryRequirementsInfo2(&unboxMapping, res);
    return res;
}

VkImageMemoryRequirementsInfo2* unbox_VkImageMemoryRequirementsInfo2(
    Pool* pool,
    const VkImageMemoryRequirementsInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageMemoryRequirementsInfo2* res = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
    deepcopy_VkImageMemoryRequirementsInfo2(pool, toUnbox, res);
    handlemap_VkImageMemoryRequirementsInfo2(&unboxMapping, res);
    return res;
}

VkImageSparseMemoryRequirementsInfo2* unbox_VkImageSparseMemoryRequirementsInfo2(
    Pool* pool,
    const VkImageSparseMemoryRequirementsInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageSparseMemoryRequirementsInfo2* res = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
    deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, toUnbox, res);
    handlemap_VkImageSparseMemoryRequirementsInfo2(&unboxMapping, res);
    return res;
}

VkMemoryRequirements2* unbox_VkMemoryRequirements2(
    Pool* pool,
    const VkMemoryRequirements2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryRequirements2* res = (VkMemoryRequirements2*)pool->alloc(sizeof(const VkMemoryRequirements2));
    deepcopy_VkMemoryRequirements2(pool, toUnbox, res);
    handlemap_VkMemoryRequirements2(&unboxMapping, res);
    return res;
}

VkSparseImageMemoryRequirements2* unbox_VkSparseImageMemoryRequirements2(
    Pool* pool,
    const VkSparseImageMemoryRequirements2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageMemoryRequirements2* res = (VkSparseImageMemoryRequirements2*)pool->alloc(sizeof(const VkSparseImageMemoryRequirements2));
    deepcopy_VkSparseImageMemoryRequirements2(pool, toUnbox, res);
    handlemap_VkSparseImageMemoryRequirements2(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceFeatures2* unbox_VkPhysicalDeviceFeatures2(
    Pool* pool,
    const VkPhysicalDeviceFeatures2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceFeatures2* res = (VkPhysicalDeviceFeatures2*)pool->alloc(sizeof(const VkPhysicalDeviceFeatures2));
    deepcopy_VkPhysicalDeviceFeatures2(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceFeatures2(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceProperties2* unbox_VkPhysicalDeviceProperties2(
    Pool* pool,
    const VkPhysicalDeviceProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceProperties2* res = (VkPhysicalDeviceProperties2*)pool->alloc(sizeof(const VkPhysicalDeviceProperties2));
    deepcopy_VkPhysicalDeviceProperties2(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceProperties2(&unboxMapping, res);
    return res;
}

VkFormatProperties2* unbox_VkFormatProperties2(
    Pool* pool,
    const VkFormatProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFormatProperties2* res = (VkFormatProperties2*)pool->alloc(sizeof(const VkFormatProperties2));
    deepcopy_VkFormatProperties2(pool, toUnbox, res);
    handlemap_VkFormatProperties2(&unboxMapping, res);
    return res;
}

VkImageFormatProperties2* unbox_VkImageFormatProperties2(
    Pool* pool,
    const VkImageFormatProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageFormatProperties2* res = (VkImageFormatProperties2*)pool->alloc(sizeof(const VkImageFormatProperties2));
    deepcopy_VkImageFormatProperties2(pool, toUnbox, res);
    handlemap_VkImageFormatProperties2(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceImageFormatInfo2* unbox_VkPhysicalDeviceImageFormatInfo2(
    Pool* pool,
    const VkPhysicalDeviceImageFormatInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceImageFormatInfo2* res = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
    deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceImageFormatInfo2(&unboxMapping, res);
    return res;
}

VkQueueFamilyProperties2* unbox_VkQueueFamilyProperties2(
    Pool* pool,
    const VkQueueFamilyProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkQueueFamilyProperties2* res = (VkQueueFamilyProperties2*)pool->alloc(sizeof(const VkQueueFamilyProperties2));
    deepcopy_VkQueueFamilyProperties2(pool, toUnbox, res);
    handlemap_VkQueueFamilyProperties2(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceMemoryProperties2* unbox_VkPhysicalDeviceMemoryProperties2(
    Pool* pool,
    const VkPhysicalDeviceMemoryProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMemoryProperties2* res = (VkPhysicalDeviceMemoryProperties2*)pool->alloc(sizeof(const VkPhysicalDeviceMemoryProperties2));
    deepcopy_VkPhysicalDeviceMemoryProperties2(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMemoryProperties2(&unboxMapping, res);
    return res;
}

VkSparseImageFormatProperties2* unbox_VkSparseImageFormatProperties2(
    Pool* pool,
    const VkSparseImageFormatProperties2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSparseImageFormatProperties2* res = (VkSparseImageFormatProperties2*)pool->alloc(sizeof(const VkSparseImageFormatProperties2));
    deepcopy_VkSparseImageFormatProperties2(pool, toUnbox, res);
    handlemap_VkSparseImageFormatProperties2(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceSparseImageFormatInfo2* unbox_VkPhysicalDeviceSparseImageFormatInfo2(
    Pool* pool,
    const VkPhysicalDeviceSparseImageFormatInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSparseImageFormatInfo2* res = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
    deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSparseImageFormatInfo2(&unboxMapping, res);
    return res;
}

VkPhysicalDevicePointClippingProperties* unbox_VkPhysicalDevicePointClippingProperties(
    Pool* pool,
    const VkPhysicalDevicePointClippingProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDevicePointClippingProperties* res = (VkPhysicalDevicePointClippingProperties*)pool->alloc(sizeof(const VkPhysicalDevicePointClippingProperties));
    deepcopy_VkPhysicalDevicePointClippingProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDevicePointClippingProperties(&unboxMapping, res);
    return res;
}

VkInputAttachmentAspectReference* unbox_VkInputAttachmentAspectReference(
    Pool* pool,
    const VkInputAttachmentAspectReference* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkInputAttachmentAspectReference* res = (VkInputAttachmentAspectReference*)pool->alloc(sizeof(const VkInputAttachmentAspectReference));
    deepcopy_VkInputAttachmentAspectReference(pool, toUnbox, res);
    handlemap_VkInputAttachmentAspectReference(&unboxMapping, res);
    return res;
}

VkRenderPassInputAttachmentAspectCreateInfo* unbox_VkRenderPassInputAttachmentAspectCreateInfo(
    Pool* pool,
    const VkRenderPassInputAttachmentAspectCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassInputAttachmentAspectCreateInfo* res = (VkRenderPassInputAttachmentAspectCreateInfo*)pool->alloc(sizeof(const VkRenderPassInputAttachmentAspectCreateInfo));
    deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(pool, toUnbox, res);
    handlemap_VkRenderPassInputAttachmentAspectCreateInfo(&unboxMapping, res);
    return res;
}

VkImageViewUsageCreateInfo* unbox_VkImageViewUsageCreateInfo(
    Pool* pool,
    const VkImageViewUsageCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageViewUsageCreateInfo* res = (VkImageViewUsageCreateInfo*)pool->alloc(sizeof(const VkImageViewUsageCreateInfo));
    deepcopy_VkImageViewUsageCreateInfo(pool, toUnbox, res);
    handlemap_VkImageViewUsageCreateInfo(&unboxMapping, res);
    return res;
}

VkPipelineTessellationDomainOriginStateCreateInfo* unbox_VkPipelineTessellationDomainOriginStateCreateInfo(
    Pool* pool,
    const VkPipelineTessellationDomainOriginStateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineTessellationDomainOriginStateCreateInfo* res = (VkPipelineTessellationDomainOriginStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationDomainOriginStateCreateInfo));
    deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(pool, toUnbox, res);
    handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(&unboxMapping, res);
    return res;
}

VkRenderPassMultiviewCreateInfo* unbox_VkRenderPassMultiviewCreateInfo(
    Pool* pool,
    const VkRenderPassMultiviewCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassMultiviewCreateInfo* res = (VkRenderPassMultiviewCreateInfo*)pool->alloc(sizeof(const VkRenderPassMultiviewCreateInfo));
    deepcopy_VkRenderPassMultiviewCreateInfo(pool, toUnbox, res);
    handlemap_VkRenderPassMultiviewCreateInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceMultiviewFeatures* unbox_VkPhysicalDeviceMultiviewFeatures(
    Pool* pool,
    const VkPhysicalDeviceMultiviewFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMultiviewFeatures* res = (VkPhysicalDeviceMultiviewFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceMultiviewFeatures));
    deepcopy_VkPhysicalDeviceMultiviewFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMultiviewFeatures(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceMultiviewProperties* unbox_VkPhysicalDeviceMultiviewProperties(
    Pool* pool,
    const VkPhysicalDeviceMultiviewProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMultiviewProperties* res = (VkPhysicalDeviceMultiviewProperties*)pool->alloc(sizeof(const VkPhysicalDeviceMultiviewProperties));
    deepcopy_VkPhysicalDeviceMultiviewProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMultiviewProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceVariablePointerFeatures* unbox_VkPhysicalDeviceVariablePointerFeatures(
    Pool* pool,
    const VkPhysicalDeviceVariablePointerFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceVariablePointerFeatures* res = (VkPhysicalDeviceVariablePointerFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceVariablePointerFeatures));
    deepcopy_VkPhysicalDeviceVariablePointerFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceVariablePointerFeatures(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceProtectedMemoryFeatures* unbox_VkPhysicalDeviceProtectedMemoryFeatures(
    Pool* pool,
    const VkPhysicalDeviceProtectedMemoryFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceProtectedMemoryFeatures* res = (VkPhysicalDeviceProtectedMemoryFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceProtectedMemoryFeatures));
    deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceProtectedMemoryFeatures(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceProtectedMemoryProperties* unbox_VkPhysicalDeviceProtectedMemoryProperties(
    Pool* pool,
    const VkPhysicalDeviceProtectedMemoryProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceProtectedMemoryProperties* res = (VkPhysicalDeviceProtectedMemoryProperties*)pool->alloc(sizeof(const VkPhysicalDeviceProtectedMemoryProperties));
    deepcopy_VkPhysicalDeviceProtectedMemoryProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceProtectedMemoryProperties(&unboxMapping, res);
    return res;
}

VkDeviceQueueInfo2* unbox_VkDeviceQueueInfo2(
    Pool* pool,
    const VkDeviceQueueInfo2* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceQueueInfo2* res = (VkDeviceQueueInfo2*)pool->alloc(sizeof(const VkDeviceQueueInfo2));
    deepcopy_VkDeviceQueueInfo2(pool, toUnbox, res);
    handlemap_VkDeviceQueueInfo2(&unboxMapping, res);
    return res;
}

VkProtectedSubmitInfo* unbox_VkProtectedSubmitInfo(
    Pool* pool,
    const VkProtectedSubmitInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkProtectedSubmitInfo* res = (VkProtectedSubmitInfo*)pool->alloc(sizeof(const VkProtectedSubmitInfo));
    deepcopy_VkProtectedSubmitInfo(pool, toUnbox, res);
    handlemap_VkProtectedSubmitInfo(&unboxMapping, res);
    return res;
}

VkSamplerYcbcrConversionCreateInfo* unbox_VkSamplerYcbcrConversionCreateInfo(
    Pool* pool,
    const VkSamplerYcbcrConversionCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSamplerYcbcrConversionCreateInfo* res = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
    deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, toUnbox, res);
    handlemap_VkSamplerYcbcrConversionCreateInfo(&unboxMapping, res);
    return res;
}

VkSamplerYcbcrConversionInfo* unbox_VkSamplerYcbcrConversionInfo(
    Pool* pool,
    const VkSamplerYcbcrConversionInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSamplerYcbcrConversionInfo* res = (VkSamplerYcbcrConversionInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionInfo));
    deepcopy_VkSamplerYcbcrConversionInfo(pool, toUnbox, res);
    handlemap_VkSamplerYcbcrConversionInfo(&unboxMapping, res);
    return res;
}

VkBindImagePlaneMemoryInfo* unbox_VkBindImagePlaneMemoryInfo(
    Pool* pool,
    const VkBindImagePlaneMemoryInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindImagePlaneMemoryInfo* res = (VkBindImagePlaneMemoryInfo*)pool->alloc(sizeof(const VkBindImagePlaneMemoryInfo));
    deepcopy_VkBindImagePlaneMemoryInfo(pool, toUnbox, res);
    handlemap_VkBindImagePlaneMemoryInfo(&unboxMapping, res);
    return res;
}

VkImagePlaneMemoryRequirementsInfo* unbox_VkImagePlaneMemoryRequirementsInfo(
    Pool* pool,
    const VkImagePlaneMemoryRequirementsInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImagePlaneMemoryRequirementsInfo* res = (VkImagePlaneMemoryRequirementsInfo*)pool->alloc(sizeof(const VkImagePlaneMemoryRequirementsInfo));
    deepcopy_VkImagePlaneMemoryRequirementsInfo(pool, toUnbox, res);
    handlemap_VkImagePlaneMemoryRequirementsInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceSamplerYcbcrConversionFeatures* unbox_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    Pool* pool,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSamplerYcbcrConversionFeatures* res = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceSamplerYcbcrConversionFeatures));
    deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(&unboxMapping, res);
    return res;
}

VkSamplerYcbcrConversionImageFormatProperties* unbox_VkSamplerYcbcrConversionImageFormatProperties(
    Pool* pool,
    const VkSamplerYcbcrConversionImageFormatProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSamplerYcbcrConversionImageFormatProperties* res = (VkSamplerYcbcrConversionImageFormatProperties*)pool->alloc(sizeof(const VkSamplerYcbcrConversionImageFormatProperties));
    deepcopy_VkSamplerYcbcrConversionImageFormatProperties(pool, toUnbox, res);
    handlemap_VkSamplerYcbcrConversionImageFormatProperties(&unboxMapping, res);
    return res;
}

VkDescriptorUpdateTemplateEntry* unbox_VkDescriptorUpdateTemplateEntry(
    Pool* pool,
    const VkDescriptorUpdateTemplateEntry* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorUpdateTemplateEntry* res = (VkDescriptorUpdateTemplateEntry*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateEntry));
    deepcopy_VkDescriptorUpdateTemplateEntry(pool, toUnbox, res);
    handlemap_VkDescriptorUpdateTemplateEntry(&unboxMapping, res);
    return res;
}

VkDescriptorUpdateTemplateCreateInfo* unbox_VkDescriptorUpdateTemplateCreateInfo(
    Pool* pool,
    const VkDescriptorUpdateTemplateCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorUpdateTemplateCreateInfo* res = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
    deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, toUnbox, res);
    handlemap_VkDescriptorUpdateTemplateCreateInfo(&unboxMapping, res);
    return res;
}

VkExternalMemoryProperties* unbox_VkExternalMemoryProperties(
    Pool* pool,
    const VkExternalMemoryProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalMemoryProperties* res = (VkExternalMemoryProperties*)pool->alloc(sizeof(const VkExternalMemoryProperties));
    deepcopy_VkExternalMemoryProperties(pool, toUnbox, res);
    handlemap_VkExternalMemoryProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceExternalImageFormatInfo* unbox_VkPhysicalDeviceExternalImageFormatInfo(
    Pool* pool,
    const VkPhysicalDeviceExternalImageFormatInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceExternalImageFormatInfo* res = (VkPhysicalDeviceExternalImageFormatInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalImageFormatInfo));
    deepcopy_VkPhysicalDeviceExternalImageFormatInfo(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceExternalImageFormatInfo(&unboxMapping, res);
    return res;
}

VkExternalImageFormatProperties* unbox_VkExternalImageFormatProperties(
    Pool* pool,
    const VkExternalImageFormatProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalImageFormatProperties* res = (VkExternalImageFormatProperties*)pool->alloc(sizeof(const VkExternalImageFormatProperties));
    deepcopy_VkExternalImageFormatProperties(pool, toUnbox, res);
    handlemap_VkExternalImageFormatProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceExternalBufferInfo* unbox_VkPhysicalDeviceExternalBufferInfo(
    Pool* pool,
    const VkPhysicalDeviceExternalBufferInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceExternalBufferInfo* res = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
    deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceExternalBufferInfo(&unboxMapping, res);
    return res;
}

VkExternalBufferProperties* unbox_VkExternalBufferProperties(
    Pool* pool,
    const VkExternalBufferProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalBufferProperties* res = (VkExternalBufferProperties*)pool->alloc(sizeof(const VkExternalBufferProperties));
    deepcopy_VkExternalBufferProperties(pool, toUnbox, res);
    handlemap_VkExternalBufferProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceIDProperties* unbox_VkPhysicalDeviceIDProperties(
    Pool* pool,
    const VkPhysicalDeviceIDProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceIDProperties* res = (VkPhysicalDeviceIDProperties*)pool->alloc(sizeof(const VkPhysicalDeviceIDProperties));
    deepcopy_VkPhysicalDeviceIDProperties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceIDProperties(&unboxMapping, res);
    return res;
}

VkExternalMemoryImageCreateInfo* unbox_VkExternalMemoryImageCreateInfo(
    Pool* pool,
    const VkExternalMemoryImageCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalMemoryImageCreateInfo* res = (VkExternalMemoryImageCreateInfo*)pool->alloc(sizeof(const VkExternalMemoryImageCreateInfo));
    deepcopy_VkExternalMemoryImageCreateInfo(pool, toUnbox, res);
    handlemap_VkExternalMemoryImageCreateInfo(&unboxMapping, res);
    return res;
}

VkExternalMemoryBufferCreateInfo* unbox_VkExternalMemoryBufferCreateInfo(
    Pool* pool,
    const VkExternalMemoryBufferCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalMemoryBufferCreateInfo* res = (VkExternalMemoryBufferCreateInfo*)pool->alloc(sizeof(const VkExternalMemoryBufferCreateInfo));
    deepcopy_VkExternalMemoryBufferCreateInfo(pool, toUnbox, res);
    handlemap_VkExternalMemoryBufferCreateInfo(&unboxMapping, res);
    return res;
}

VkExportMemoryAllocateInfo* unbox_VkExportMemoryAllocateInfo(
    Pool* pool,
    const VkExportMemoryAllocateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportMemoryAllocateInfo* res = (VkExportMemoryAllocateInfo*)pool->alloc(sizeof(const VkExportMemoryAllocateInfo));
    deepcopy_VkExportMemoryAllocateInfo(pool, toUnbox, res);
    handlemap_VkExportMemoryAllocateInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceExternalFenceInfo* unbox_VkPhysicalDeviceExternalFenceInfo(
    Pool* pool,
    const VkPhysicalDeviceExternalFenceInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceExternalFenceInfo* res = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
    deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceExternalFenceInfo(&unboxMapping, res);
    return res;
}

VkExternalFenceProperties* unbox_VkExternalFenceProperties(
    Pool* pool,
    const VkExternalFenceProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalFenceProperties* res = (VkExternalFenceProperties*)pool->alloc(sizeof(const VkExternalFenceProperties));
    deepcopy_VkExternalFenceProperties(pool, toUnbox, res);
    handlemap_VkExternalFenceProperties(&unboxMapping, res);
    return res;
}

VkExportFenceCreateInfo* unbox_VkExportFenceCreateInfo(
    Pool* pool,
    const VkExportFenceCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportFenceCreateInfo* res = (VkExportFenceCreateInfo*)pool->alloc(sizeof(const VkExportFenceCreateInfo));
    deepcopy_VkExportFenceCreateInfo(pool, toUnbox, res);
    handlemap_VkExportFenceCreateInfo(&unboxMapping, res);
    return res;
}

VkExportSemaphoreCreateInfo* unbox_VkExportSemaphoreCreateInfo(
    Pool* pool,
    const VkExportSemaphoreCreateInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportSemaphoreCreateInfo* res = (VkExportSemaphoreCreateInfo*)pool->alloc(sizeof(const VkExportSemaphoreCreateInfo));
    deepcopy_VkExportSemaphoreCreateInfo(pool, toUnbox, res);
    handlemap_VkExportSemaphoreCreateInfo(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceExternalSemaphoreInfo* unbox_VkPhysicalDeviceExternalSemaphoreInfo(
    Pool* pool,
    const VkPhysicalDeviceExternalSemaphoreInfo* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceExternalSemaphoreInfo* res = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
    deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceExternalSemaphoreInfo(&unboxMapping, res);
    return res;
}

VkExternalSemaphoreProperties* unbox_VkExternalSemaphoreProperties(
    Pool* pool,
    const VkExternalSemaphoreProperties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalSemaphoreProperties* res = (VkExternalSemaphoreProperties*)pool->alloc(sizeof(const VkExternalSemaphoreProperties));
    deepcopy_VkExternalSemaphoreProperties(pool, toUnbox, res);
    handlemap_VkExternalSemaphoreProperties(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceMaintenance3Properties* unbox_VkPhysicalDeviceMaintenance3Properties(
    Pool* pool,
    const VkPhysicalDeviceMaintenance3Properties* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMaintenance3Properties* res = (VkPhysicalDeviceMaintenance3Properties*)pool->alloc(sizeof(const VkPhysicalDeviceMaintenance3Properties));
    deepcopy_VkPhysicalDeviceMaintenance3Properties(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMaintenance3Properties(&unboxMapping, res);
    return res;
}

VkDescriptorSetLayoutSupport* unbox_VkDescriptorSetLayoutSupport(
    Pool* pool,
    const VkDescriptorSetLayoutSupport* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetLayoutSupport* res = (VkDescriptorSetLayoutSupport*)pool->alloc(sizeof(const VkDescriptorSetLayoutSupport));
    deepcopy_VkDescriptorSetLayoutSupport(pool, toUnbox, res);
    handlemap_VkDescriptorSetLayoutSupport(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceShaderDrawParameterFeatures* unbox_VkPhysicalDeviceShaderDrawParameterFeatures(
    Pool* pool,
    const VkPhysicalDeviceShaderDrawParameterFeatures* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceShaderDrawParameterFeatures* res = (VkPhysicalDeviceShaderDrawParameterFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceShaderDrawParameterFeatures));
    deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_surface
VkSurfaceCapabilitiesKHR* unbox_VkSurfaceCapabilitiesKHR(
    Pool* pool,
    const VkSurfaceCapabilitiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSurfaceCapabilitiesKHR* res = (VkSurfaceCapabilitiesKHR*)pool->alloc(sizeof(const VkSurfaceCapabilitiesKHR));
    deepcopy_VkSurfaceCapabilitiesKHR(pool, toUnbox, res);
    handlemap_VkSurfaceCapabilitiesKHR(&unboxMapping, res);
    return res;
}

VkSurfaceFormatKHR* unbox_VkSurfaceFormatKHR(
    Pool* pool,
    const VkSurfaceFormatKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSurfaceFormatKHR* res = (VkSurfaceFormatKHR*)pool->alloc(sizeof(const VkSurfaceFormatKHR));
    deepcopy_VkSurfaceFormatKHR(pool, toUnbox, res);
    handlemap_VkSurfaceFormatKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_swapchain
VkSwapchainCreateInfoKHR* unbox_VkSwapchainCreateInfoKHR(
    Pool* pool,
    const VkSwapchainCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSwapchainCreateInfoKHR* res = (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
    deepcopy_VkSwapchainCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkSwapchainCreateInfoKHR(&unboxMapping, res);
    return res;
}

VkPresentInfoKHR* unbox_VkPresentInfoKHR(
    Pool* pool,
    const VkPresentInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPresentInfoKHR* res = (VkPresentInfoKHR*)pool->alloc(sizeof(const VkPresentInfoKHR));
    deepcopy_VkPresentInfoKHR(pool, toUnbox, res);
    handlemap_VkPresentInfoKHR(&unboxMapping, res);
    return res;
}

VkImageSwapchainCreateInfoKHR* unbox_VkImageSwapchainCreateInfoKHR(
    Pool* pool,
    const VkImageSwapchainCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageSwapchainCreateInfoKHR* res = (VkImageSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkImageSwapchainCreateInfoKHR));
    deepcopy_VkImageSwapchainCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkImageSwapchainCreateInfoKHR(&unboxMapping, res);
    return res;
}

VkBindImageMemorySwapchainInfoKHR* unbox_VkBindImageMemorySwapchainInfoKHR(
    Pool* pool,
    const VkBindImageMemorySwapchainInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkBindImageMemorySwapchainInfoKHR* res = (VkBindImageMemorySwapchainInfoKHR*)pool->alloc(sizeof(const VkBindImageMemorySwapchainInfoKHR));
    deepcopy_VkBindImageMemorySwapchainInfoKHR(pool, toUnbox, res);
    handlemap_VkBindImageMemorySwapchainInfoKHR(&unboxMapping, res);
    return res;
}

VkAcquireNextImageInfoKHR* unbox_VkAcquireNextImageInfoKHR(
    Pool* pool,
    const VkAcquireNextImageInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAcquireNextImageInfoKHR* res = (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
    deepcopy_VkAcquireNextImageInfoKHR(pool, toUnbox, res);
    handlemap_VkAcquireNextImageInfoKHR(&unboxMapping, res);
    return res;
}

VkDeviceGroupPresentCapabilitiesKHR* unbox_VkDeviceGroupPresentCapabilitiesKHR(
    Pool* pool,
    const VkDeviceGroupPresentCapabilitiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupPresentCapabilitiesKHR* res = (VkDeviceGroupPresentCapabilitiesKHR*)pool->alloc(sizeof(const VkDeviceGroupPresentCapabilitiesKHR));
    deepcopy_VkDeviceGroupPresentCapabilitiesKHR(pool, toUnbox, res);
    handlemap_VkDeviceGroupPresentCapabilitiesKHR(&unboxMapping, res);
    return res;
}

VkDeviceGroupPresentInfoKHR* unbox_VkDeviceGroupPresentInfoKHR(
    Pool* pool,
    const VkDeviceGroupPresentInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupPresentInfoKHR* res = (VkDeviceGroupPresentInfoKHR*)pool->alloc(sizeof(const VkDeviceGroupPresentInfoKHR));
    deepcopy_VkDeviceGroupPresentInfoKHR(pool, toUnbox, res);
    handlemap_VkDeviceGroupPresentInfoKHR(&unboxMapping, res);
    return res;
}

VkDeviceGroupSwapchainCreateInfoKHR* unbox_VkDeviceGroupSwapchainCreateInfoKHR(
    Pool* pool,
    const VkDeviceGroupSwapchainCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGroupSwapchainCreateInfoKHR* res = (VkDeviceGroupSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkDeviceGroupSwapchainCreateInfoKHR));
    deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkDeviceGroupSwapchainCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_display
VkDisplayPropertiesKHR* unbox_VkDisplayPropertiesKHR(
    Pool* pool,
    const VkDisplayPropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPropertiesKHR* res = (VkDisplayPropertiesKHR*)pool->alloc(sizeof(const VkDisplayPropertiesKHR));
    deepcopy_VkDisplayPropertiesKHR(pool, toUnbox, res);
    handlemap_VkDisplayPropertiesKHR(&unboxMapping, res);
    return res;
}

VkDisplayModeParametersKHR* unbox_VkDisplayModeParametersKHR(
    Pool* pool,
    const VkDisplayModeParametersKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayModeParametersKHR* res = (VkDisplayModeParametersKHR*)pool->alloc(sizeof(const VkDisplayModeParametersKHR));
    deepcopy_VkDisplayModeParametersKHR(pool, toUnbox, res);
    handlemap_VkDisplayModeParametersKHR(&unboxMapping, res);
    return res;
}

VkDisplayModePropertiesKHR* unbox_VkDisplayModePropertiesKHR(
    Pool* pool,
    const VkDisplayModePropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayModePropertiesKHR* res = (VkDisplayModePropertiesKHR*)pool->alloc(sizeof(const VkDisplayModePropertiesKHR));
    deepcopy_VkDisplayModePropertiesKHR(pool, toUnbox, res);
    handlemap_VkDisplayModePropertiesKHR(&unboxMapping, res);
    return res;
}

VkDisplayModeCreateInfoKHR* unbox_VkDisplayModeCreateInfoKHR(
    Pool* pool,
    const VkDisplayModeCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayModeCreateInfoKHR* res = (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
    deepcopy_VkDisplayModeCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkDisplayModeCreateInfoKHR(&unboxMapping, res);
    return res;
}

VkDisplayPlaneCapabilitiesKHR* unbox_VkDisplayPlaneCapabilitiesKHR(
    Pool* pool,
    const VkDisplayPlaneCapabilitiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPlaneCapabilitiesKHR* res = (VkDisplayPlaneCapabilitiesKHR*)pool->alloc(sizeof(const VkDisplayPlaneCapabilitiesKHR));
    deepcopy_VkDisplayPlaneCapabilitiesKHR(pool, toUnbox, res);
    handlemap_VkDisplayPlaneCapabilitiesKHR(&unboxMapping, res);
    return res;
}

VkDisplayPlanePropertiesKHR* unbox_VkDisplayPlanePropertiesKHR(
    Pool* pool,
    const VkDisplayPlanePropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPlanePropertiesKHR* res = (VkDisplayPlanePropertiesKHR*)pool->alloc(sizeof(const VkDisplayPlanePropertiesKHR));
    deepcopy_VkDisplayPlanePropertiesKHR(pool, toUnbox, res);
    handlemap_VkDisplayPlanePropertiesKHR(&unboxMapping, res);
    return res;
}

VkDisplaySurfaceCreateInfoKHR* unbox_VkDisplaySurfaceCreateInfoKHR(
    Pool* pool,
    const VkDisplaySurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplaySurfaceCreateInfoKHR* res = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkDisplaySurfaceCreateInfoKHR));
    deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkDisplaySurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_display_swapchain
VkDisplayPresentInfoKHR* unbox_VkDisplayPresentInfoKHR(
    Pool* pool,
    const VkDisplayPresentInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPresentInfoKHR* res = (VkDisplayPresentInfoKHR*)pool->alloc(sizeof(const VkDisplayPresentInfoKHR));
    deepcopy_VkDisplayPresentInfoKHR(pool, toUnbox, res);
    handlemap_VkDisplayPresentInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_xlib_surface
VkXlibSurfaceCreateInfoKHR* unbox_VkXlibSurfaceCreateInfoKHR(
    Pool* pool,
    const VkXlibSurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkXlibSurfaceCreateInfoKHR* res = (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
    deepcopy_VkXlibSurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkXlibSurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_xcb_surface
VkXcbSurfaceCreateInfoKHR* unbox_VkXcbSurfaceCreateInfoKHR(
    Pool* pool,
    const VkXcbSurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkXcbSurfaceCreateInfoKHR* res = (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
    deepcopy_VkXcbSurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkXcbSurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_wayland_surface
VkWaylandSurfaceCreateInfoKHR* unbox_VkWaylandSurfaceCreateInfoKHR(
    Pool* pool,
    const VkWaylandSurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkWaylandSurfaceCreateInfoKHR* res = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWaylandSurfaceCreateInfoKHR));
    deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkWaylandSurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_mir_surface
VkMirSurfaceCreateInfoKHR* unbox_VkMirSurfaceCreateInfoKHR(
    Pool* pool,
    const VkMirSurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMirSurfaceCreateInfoKHR* res = (VkMirSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkMirSurfaceCreateInfoKHR));
    deepcopy_VkMirSurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkMirSurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_android_surface
VkAndroidSurfaceCreateInfoKHR* unbox_VkAndroidSurfaceCreateInfoKHR(
    Pool* pool,
    const VkAndroidSurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAndroidSurfaceCreateInfoKHR* res = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkAndroidSurfaceCreateInfoKHR));
    deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkAndroidSurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_win32_surface
VkWin32SurfaceCreateInfoKHR* unbox_VkWin32SurfaceCreateInfoKHR(
    Pool* pool,
    const VkWin32SurfaceCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkWin32SurfaceCreateInfoKHR* res = (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
    deepcopy_VkWin32SurfaceCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkWin32SurfaceCreateInfoKHR(&unboxMapping, res);
    return res;
}

#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
VkImportMemoryWin32HandleInfoKHR* unbox_VkImportMemoryWin32HandleInfoKHR(
    Pool* pool,
    const VkImportMemoryWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportMemoryWin32HandleInfoKHR* res = (VkImportMemoryWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportMemoryWin32HandleInfoKHR));
    deepcopy_VkImportMemoryWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkImportMemoryWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkExportMemoryWin32HandleInfoKHR* unbox_VkExportMemoryWin32HandleInfoKHR(
    Pool* pool,
    const VkExportMemoryWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportMemoryWin32HandleInfoKHR* res = (VkExportMemoryWin32HandleInfoKHR*)pool->alloc(sizeof(const VkExportMemoryWin32HandleInfoKHR));
    deepcopy_VkExportMemoryWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkExportMemoryWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkMemoryWin32HandlePropertiesKHR* unbox_VkMemoryWin32HandlePropertiesKHR(
    Pool* pool,
    const VkMemoryWin32HandlePropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryWin32HandlePropertiesKHR* res = (VkMemoryWin32HandlePropertiesKHR*)pool->alloc(sizeof(const VkMemoryWin32HandlePropertiesKHR));
    deepcopy_VkMemoryWin32HandlePropertiesKHR(pool, toUnbox, res);
    handlemap_VkMemoryWin32HandlePropertiesKHR(&unboxMapping, res);
    return res;
}

VkMemoryGetWin32HandleInfoKHR* unbox_VkMemoryGetWin32HandleInfoKHR(
    Pool* pool,
    const VkMemoryGetWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryGetWin32HandleInfoKHR* res = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkMemoryGetWin32HandleInfoKHR));
    deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkMemoryGetWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_external_memory_fd
VkImportMemoryFdInfoKHR* unbox_VkImportMemoryFdInfoKHR(
    Pool* pool,
    const VkImportMemoryFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportMemoryFdInfoKHR* res = (VkImportMemoryFdInfoKHR*)pool->alloc(sizeof(const VkImportMemoryFdInfoKHR));
    deepcopy_VkImportMemoryFdInfoKHR(pool, toUnbox, res);
    handlemap_VkImportMemoryFdInfoKHR(&unboxMapping, res);
    return res;
}

VkMemoryFdPropertiesKHR* unbox_VkMemoryFdPropertiesKHR(
    Pool* pool,
    const VkMemoryFdPropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryFdPropertiesKHR* res = (VkMemoryFdPropertiesKHR*)pool->alloc(sizeof(const VkMemoryFdPropertiesKHR));
    deepcopy_VkMemoryFdPropertiesKHR(pool, toUnbox, res);
    handlemap_VkMemoryFdPropertiesKHR(&unboxMapping, res);
    return res;
}

VkMemoryGetFdInfoKHR* unbox_VkMemoryGetFdInfoKHR(
    Pool* pool,
    const VkMemoryGetFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryGetFdInfoKHR* res = (VkMemoryGetFdInfoKHR*)pool->alloc(sizeof(const VkMemoryGetFdInfoKHR));
    deepcopy_VkMemoryGetFdInfoKHR(pool, toUnbox, res);
    handlemap_VkMemoryGetFdInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
VkWin32KeyedMutexAcquireReleaseInfoKHR* unbox_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    Pool* pool,
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkWin32KeyedMutexAcquireReleaseInfoKHR* res = (VkWin32KeyedMutexAcquireReleaseInfoKHR*)pool->alloc(sizeof(const VkWin32KeyedMutexAcquireReleaseInfoKHR));
    deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(pool, toUnbox, res);
    handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_external_semaphore_capabilities
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
VkImportSemaphoreWin32HandleInfoKHR* unbox_VkImportSemaphoreWin32HandleInfoKHR(
    Pool* pool,
    const VkImportSemaphoreWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportSemaphoreWin32HandleInfoKHR* res = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
    deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkImportSemaphoreWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkExportSemaphoreWin32HandleInfoKHR* unbox_VkExportSemaphoreWin32HandleInfoKHR(
    Pool* pool,
    const VkExportSemaphoreWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportSemaphoreWin32HandleInfoKHR* res = (VkExportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkExportSemaphoreWin32HandleInfoKHR));
    deepcopy_VkExportSemaphoreWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkExportSemaphoreWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkD3D12FenceSubmitInfoKHR* unbox_VkD3D12FenceSubmitInfoKHR(
    Pool* pool,
    const VkD3D12FenceSubmitInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkD3D12FenceSubmitInfoKHR* res = (VkD3D12FenceSubmitInfoKHR*)pool->alloc(sizeof(const VkD3D12FenceSubmitInfoKHR));
    deepcopy_VkD3D12FenceSubmitInfoKHR(pool, toUnbox, res);
    handlemap_VkD3D12FenceSubmitInfoKHR(&unboxMapping, res);
    return res;
}

VkSemaphoreGetWin32HandleInfoKHR* unbox_VkSemaphoreGetWin32HandleInfoKHR(
    Pool* pool,
    const VkSemaphoreGetWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSemaphoreGetWin32HandleInfoKHR* res = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
    deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkSemaphoreGetWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_external_semaphore_fd
VkImportSemaphoreFdInfoKHR* unbox_VkImportSemaphoreFdInfoKHR(
    Pool* pool,
    const VkImportSemaphoreFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportSemaphoreFdInfoKHR* res = (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
    deepcopy_VkImportSemaphoreFdInfoKHR(pool, toUnbox, res);
    handlemap_VkImportSemaphoreFdInfoKHR(&unboxMapping, res);
    return res;
}

VkSemaphoreGetFdInfoKHR* unbox_VkSemaphoreGetFdInfoKHR(
    Pool* pool,
    const VkSemaphoreGetFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSemaphoreGetFdInfoKHR* res = (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
    deepcopy_VkSemaphoreGetFdInfoKHR(pool, toUnbox, res);
    handlemap_VkSemaphoreGetFdInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_push_descriptor
VkPhysicalDevicePushDescriptorPropertiesKHR* unbox_VkPhysicalDevicePushDescriptorPropertiesKHR(
    Pool* pool,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDevicePushDescriptorPropertiesKHR* res = (VkPhysicalDevicePushDescriptorPropertiesKHR*)pool->alloc(sizeof(const VkPhysicalDevicePushDescriptorPropertiesKHR));
    deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(pool, toUnbox, res);
    handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
VkRectLayerKHR* unbox_VkRectLayerKHR(
    Pool* pool,
    const VkRectLayerKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRectLayerKHR* res = (VkRectLayerKHR*)pool->alloc(sizeof(const VkRectLayerKHR));
    deepcopy_VkRectLayerKHR(pool, toUnbox, res);
    handlemap_VkRectLayerKHR(&unboxMapping, res);
    return res;
}

VkPresentRegionKHR* unbox_VkPresentRegionKHR(
    Pool* pool,
    const VkPresentRegionKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPresentRegionKHR* res = (VkPresentRegionKHR*)pool->alloc(sizeof(const VkPresentRegionKHR));
    deepcopy_VkPresentRegionKHR(pool, toUnbox, res);
    handlemap_VkPresentRegionKHR(&unboxMapping, res);
    return res;
}

VkPresentRegionsKHR* unbox_VkPresentRegionsKHR(
    Pool* pool,
    const VkPresentRegionsKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPresentRegionsKHR* res = (VkPresentRegionsKHR*)pool->alloc(sizeof(const VkPresentRegionsKHR));
    deepcopy_VkPresentRegionsKHR(pool, toUnbox, res);
    handlemap_VkPresentRegionsKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_descriptor_update_template
#endif
#ifdef VK_KHR_create_renderpass2
VkAttachmentDescription2KHR* unbox_VkAttachmentDescription2KHR(
    Pool* pool,
    const VkAttachmentDescription2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAttachmentDescription2KHR* res = (VkAttachmentDescription2KHR*)pool->alloc(sizeof(const VkAttachmentDescription2KHR));
    deepcopy_VkAttachmentDescription2KHR(pool, toUnbox, res);
    handlemap_VkAttachmentDescription2KHR(&unboxMapping, res);
    return res;
}

VkAttachmentReference2KHR* unbox_VkAttachmentReference2KHR(
    Pool* pool,
    const VkAttachmentReference2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAttachmentReference2KHR* res = (VkAttachmentReference2KHR*)pool->alloc(sizeof(const VkAttachmentReference2KHR));
    deepcopy_VkAttachmentReference2KHR(pool, toUnbox, res);
    handlemap_VkAttachmentReference2KHR(&unboxMapping, res);
    return res;
}

VkSubpassDescription2KHR* unbox_VkSubpassDescription2KHR(
    Pool* pool,
    const VkSubpassDescription2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassDescription2KHR* res = (VkSubpassDescription2KHR*)pool->alloc(sizeof(const VkSubpassDescription2KHR));
    deepcopy_VkSubpassDescription2KHR(pool, toUnbox, res);
    handlemap_VkSubpassDescription2KHR(&unboxMapping, res);
    return res;
}

VkSubpassDependency2KHR* unbox_VkSubpassDependency2KHR(
    Pool* pool,
    const VkSubpassDependency2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassDependency2KHR* res = (VkSubpassDependency2KHR*)pool->alloc(sizeof(const VkSubpassDependency2KHR));
    deepcopy_VkSubpassDependency2KHR(pool, toUnbox, res);
    handlemap_VkSubpassDependency2KHR(&unboxMapping, res);
    return res;
}

VkRenderPassCreateInfo2KHR* unbox_VkRenderPassCreateInfo2KHR(
    Pool* pool,
    const VkRenderPassCreateInfo2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassCreateInfo2KHR* res = (VkRenderPassCreateInfo2KHR*)pool->alloc(sizeof(const VkRenderPassCreateInfo2KHR));
    deepcopy_VkRenderPassCreateInfo2KHR(pool, toUnbox, res);
    handlemap_VkRenderPassCreateInfo2KHR(&unboxMapping, res);
    return res;
}

VkSubpassBeginInfoKHR* unbox_VkSubpassBeginInfoKHR(
    Pool* pool,
    const VkSubpassBeginInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassBeginInfoKHR* res = (VkSubpassBeginInfoKHR*)pool->alloc(sizeof(const VkSubpassBeginInfoKHR));
    deepcopy_VkSubpassBeginInfoKHR(pool, toUnbox, res);
    handlemap_VkSubpassBeginInfoKHR(&unboxMapping, res);
    return res;
}

VkSubpassEndInfoKHR* unbox_VkSubpassEndInfoKHR(
    Pool* pool,
    const VkSubpassEndInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassEndInfoKHR* res = (VkSubpassEndInfoKHR*)pool->alloc(sizeof(const VkSubpassEndInfoKHR));
    deepcopy_VkSubpassEndInfoKHR(pool, toUnbox, res);
    handlemap_VkSubpassEndInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_shared_presentable_image
VkSharedPresentSurfaceCapabilitiesKHR* unbox_VkSharedPresentSurfaceCapabilitiesKHR(
    Pool* pool,
    const VkSharedPresentSurfaceCapabilitiesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSharedPresentSurfaceCapabilitiesKHR* res = (VkSharedPresentSurfaceCapabilitiesKHR*)pool->alloc(sizeof(const VkSharedPresentSurfaceCapabilitiesKHR));
    deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(pool, toUnbox, res);
    handlemap_VkSharedPresentSurfaceCapabilitiesKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_external_fence_capabilities
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
VkImportFenceWin32HandleInfoKHR* unbox_VkImportFenceWin32HandleInfoKHR(
    Pool* pool,
    const VkImportFenceWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportFenceWin32HandleInfoKHR* res = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportFenceWin32HandleInfoKHR));
    deepcopy_VkImportFenceWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkImportFenceWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkExportFenceWin32HandleInfoKHR* unbox_VkExportFenceWin32HandleInfoKHR(
    Pool* pool,
    const VkExportFenceWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportFenceWin32HandleInfoKHR* res = (VkExportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkExportFenceWin32HandleInfoKHR));
    deepcopy_VkExportFenceWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkExportFenceWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

VkFenceGetWin32HandleInfoKHR* unbox_VkFenceGetWin32HandleInfoKHR(
    Pool* pool,
    const VkFenceGetWin32HandleInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFenceGetWin32HandleInfoKHR* res = (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
    deepcopy_VkFenceGetWin32HandleInfoKHR(pool, toUnbox, res);
    handlemap_VkFenceGetWin32HandleInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_external_fence_fd
VkImportFenceFdInfoKHR* unbox_VkImportFenceFdInfoKHR(
    Pool* pool,
    const VkImportFenceFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportFenceFdInfoKHR* res = (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
    deepcopy_VkImportFenceFdInfoKHR(pool, toUnbox, res);
    handlemap_VkImportFenceFdInfoKHR(&unboxMapping, res);
    return res;
}

VkFenceGetFdInfoKHR* unbox_VkFenceGetFdInfoKHR(
    Pool* pool,
    const VkFenceGetFdInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkFenceGetFdInfoKHR* res = (VkFenceGetFdInfoKHR*)pool->alloc(sizeof(const VkFenceGetFdInfoKHR));
    deepcopy_VkFenceGetFdInfoKHR(pool, toUnbox, res);
    handlemap_VkFenceGetFdInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
VkPhysicalDeviceSurfaceInfo2KHR* unbox_VkPhysicalDeviceSurfaceInfo2KHR(
    Pool* pool,
    const VkPhysicalDeviceSurfaceInfo2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSurfaceInfo2KHR* res = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
    deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSurfaceInfo2KHR(&unboxMapping, res);
    return res;
}

VkSurfaceCapabilities2KHR* unbox_VkSurfaceCapabilities2KHR(
    Pool* pool,
    const VkSurfaceCapabilities2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSurfaceCapabilities2KHR* res = (VkSurfaceCapabilities2KHR*)pool->alloc(sizeof(const VkSurfaceCapabilities2KHR));
    deepcopy_VkSurfaceCapabilities2KHR(pool, toUnbox, res);
    handlemap_VkSurfaceCapabilities2KHR(&unboxMapping, res);
    return res;
}

VkSurfaceFormat2KHR* unbox_VkSurfaceFormat2KHR(
    Pool* pool,
    const VkSurfaceFormat2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSurfaceFormat2KHR* res = (VkSurfaceFormat2KHR*)pool->alloc(sizeof(const VkSurfaceFormat2KHR));
    deepcopy_VkSurfaceFormat2KHR(pool, toUnbox, res);
    handlemap_VkSurfaceFormat2KHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
VkDisplayProperties2KHR* unbox_VkDisplayProperties2KHR(
    Pool* pool,
    const VkDisplayProperties2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayProperties2KHR* res = (VkDisplayProperties2KHR*)pool->alloc(sizeof(const VkDisplayProperties2KHR));
    deepcopy_VkDisplayProperties2KHR(pool, toUnbox, res);
    handlemap_VkDisplayProperties2KHR(&unboxMapping, res);
    return res;
}

VkDisplayPlaneProperties2KHR* unbox_VkDisplayPlaneProperties2KHR(
    Pool* pool,
    const VkDisplayPlaneProperties2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPlaneProperties2KHR* res = (VkDisplayPlaneProperties2KHR*)pool->alloc(sizeof(const VkDisplayPlaneProperties2KHR));
    deepcopy_VkDisplayPlaneProperties2KHR(pool, toUnbox, res);
    handlemap_VkDisplayPlaneProperties2KHR(&unboxMapping, res);
    return res;
}

VkDisplayModeProperties2KHR* unbox_VkDisplayModeProperties2KHR(
    Pool* pool,
    const VkDisplayModeProperties2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayModeProperties2KHR* res = (VkDisplayModeProperties2KHR*)pool->alloc(sizeof(const VkDisplayModeProperties2KHR));
    deepcopy_VkDisplayModeProperties2KHR(pool, toUnbox, res);
    handlemap_VkDisplayModeProperties2KHR(&unboxMapping, res);
    return res;
}

VkDisplayPlaneInfo2KHR* unbox_VkDisplayPlaneInfo2KHR(
    Pool* pool,
    const VkDisplayPlaneInfo2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPlaneInfo2KHR* res = (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
    deepcopy_VkDisplayPlaneInfo2KHR(pool, toUnbox, res);
    handlemap_VkDisplayPlaneInfo2KHR(&unboxMapping, res);
    return res;
}

VkDisplayPlaneCapabilities2KHR* unbox_VkDisplayPlaneCapabilities2KHR(
    Pool* pool,
    const VkDisplayPlaneCapabilities2KHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPlaneCapabilities2KHR* res = (VkDisplayPlaneCapabilities2KHR*)pool->alloc(sizeof(const VkDisplayPlaneCapabilities2KHR));
    deepcopy_VkDisplayPlaneCapabilities2KHR(pool, toUnbox, res);
    handlemap_VkDisplayPlaneCapabilities2KHR(&unboxMapping, res);
    return res;
}

#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
VkImageFormatListCreateInfoKHR* unbox_VkImageFormatListCreateInfoKHR(
    Pool* pool,
    const VkImageFormatListCreateInfoKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImageFormatListCreateInfoKHR* res = (VkImageFormatListCreateInfoKHR*)pool->alloc(sizeof(const VkImageFormatListCreateInfoKHR));
    deepcopy_VkImageFormatListCreateInfoKHR(pool, toUnbox, res);
    handlemap_VkImageFormatListCreateInfoKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
#endif
#ifdef VK_KHR_bind_memory2
#endif
#ifdef VK_KHR_maintenance3
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_8bit_storage
VkPhysicalDevice8BitStorageFeaturesKHR* unbox_VkPhysicalDevice8BitStorageFeaturesKHR(
    Pool* pool,
    const VkPhysicalDevice8BitStorageFeaturesKHR* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDevice8BitStorageFeaturesKHR* res = (VkPhysicalDevice8BitStorageFeaturesKHR*)pool->alloc(sizeof(const VkPhysicalDevice8BitStorageFeaturesKHR));
    deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(pool, toUnbox, res);
    handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_ANDROID_native_buffer
VkNativeBufferANDROID* unbox_VkNativeBufferANDROID(
    Pool* pool,
    const VkNativeBufferANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkNativeBufferANDROID* res = (VkNativeBufferANDROID*)pool->alloc(sizeof(const VkNativeBufferANDROID));
    deepcopy_VkNativeBufferANDROID(pool, toUnbox, res);
    handlemap_VkNativeBufferANDROID(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_debug_report
VkDebugReportCallbackCreateInfoEXT* unbox_VkDebugReportCallbackCreateInfoEXT(
    Pool* pool,
    const VkDebugReportCallbackCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugReportCallbackCreateInfoEXT* res = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(sizeof(const VkDebugReportCallbackCreateInfoEXT));
    deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugReportCallbackCreateInfoEXT(&unboxMapping, res);
    return res;
}

#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
VkPipelineRasterizationStateRasterizationOrderAMD* unbox_VkPipelineRasterizationStateRasterizationOrderAMD(
    Pool* pool,
    const VkPipelineRasterizationStateRasterizationOrderAMD* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineRasterizationStateRasterizationOrderAMD* res = (VkPipelineRasterizationStateRasterizationOrderAMD*)pool->alloc(sizeof(const VkPipelineRasterizationStateRasterizationOrderAMD));
    deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(pool, toUnbox, res);
    handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
VkDebugMarkerObjectNameInfoEXT* unbox_VkDebugMarkerObjectNameInfoEXT(
    Pool* pool,
    const VkDebugMarkerObjectNameInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugMarkerObjectNameInfoEXT* res = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectNameInfoEXT));
    deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugMarkerObjectNameInfoEXT(&unboxMapping, res);
    return res;
}

VkDebugMarkerObjectTagInfoEXT* unbox_VkDebugMarkerObjectTagInfoEXT(
    Pool* pool,
    const VkDebugMarkerObjectTagInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugMarkerObjectTagInfoEXT* res = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectTagInfoEXT));
    deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugMarkerObjectTagInfoEXT(&unboxMapping, res);
    return res;
}

VkDebugMarkerMarkerInfoEXT* unbox_VkDebugMarkerMarkerInfoEXT(
    Pool* pool,
    const VkDebugMarkerMarkerInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugMarkerMarkerInfoEXT* res = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
    deepcopy_VkDebugMarkerMarkerInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugMarkerMarkerInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
VkDedicatedAllocationImageCreateInfoNV* unbox_VkDedicatedAllocationImageCreateInfoNV(
    Pool* pool,
    const VkDedicatedAllocationImageCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDedicatedAllocationImageCreateInfoNV* res = (VkDedicatedAllocationImageCreateInfoNV*)pool->alloc(sizeof(const VkDedicatedAllocationImageCreateInfoNV));
    deepcopy_VkDedicatedAllocationImageCreateInfoNV(pool, toUnbox, res);
    handlemap_VkDedicatedAllocationImageCreateInfoNV(&unboxMapping, res);
    return res;
}

VkDedicatedAllocationBufferCreateInfoNV* unbox_VkDedicatedAllocationBufferCreateInfoNV(
    Pool* pool,
    const VkDedicatedAllocationBufferCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDedicatedAllocationBufferCreateInfoNV* res = (VkDedicatedAllocationBufferCreateInfoNV*)pool->alloc(sizeof(const VkDedicatedAllocationBufferCreateInfoNV));
    deepcopy_VkDedicatedAllocationBufferCreateInfoNV(pool, toUnbox, res);
    handlemap_VkDedicatedAllocationBufferCreateInfoNV(&unboxMapping, res);
    return res;
}

VkDedicatedAllocationMemoryAllocateInfoNV* unbox_VkDedicatedAllocationMemoryAllocateInfoNV(
    Pool* pool,
    const VkDedicatedAllocationMemoryAllocateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDedicatedAllocationMemoryAllocateInfoNV* res = (VkDedicatedAllocationMemoryAllocateInfoNV*)pool->alloc(sizeof(const VkDedicatedAllocationMemoryAllocateInfoNV));
    deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(pool, toUnbox, res);
    handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(&unboxMapping, res);
    return res;
}

#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
VkTextureLODGatherFormatPropertiesAMD* unbox_VkTextureLODGatherFormatPropertiesAMD(
    Pool* pool,
    const VkTextureLODGatherFormatPropertiesAMD* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkTextureLODGatherFormatPropertiesAMD* res = (VkTextureLODGatherFormatPropertiesAMD*)pool->alloc(sizeof(const VkTextureLODGatherFormatPropertiesAMD));
    deepcopy_VkTextureLODGatherFormatPropertiesAMD(pool, toUnbox, res);
    handlemap_VkTextureLODGatherFormatPropertiesAMD(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_shader_info
VkShaderResourceUsageAMD* unbox_VkShaderResourceUsageAMD(
    Pool* pool,
    const VkShaderResourceUsageAMD* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkShaderResourceUsageAMD* res = (VkShaderResourceUsageAMD*)pool->alloc(sizeof(const VkShaderResourceUsageAMD));
    deepcopy_VkShaderResourceUsageAMD(pool, toUnbox, res);
    handlemap_VkShaderResourceUsageAMD(&unboxMapping, res);
    return res;
}

VkShaderStatisticsInfoAMD* unbox_VkShaderStatisticsInfoAMD(
    Pool* pool,
    const VkShaderStatisticsInfoAMD* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkShaderStatisticsInfoAMD* res = (VkShaderStatisticsInfoAMD*)pool->alloc(sizeof(const VkShaderStatisticsInfoAMD));
    deepcopy_VkShaderStatisticsInfoAMD(pool, toUnbox, res);
    handlemap_VkShaderStatisticsInfoAMD(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
VkExternalImageFormatPropertiesNV* unbox_VkExternalImageFormatPropertiesNV(
    Pool* pool,
    const VkExternalImageFormatPropertiesNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalImageFormatPropertiesNV* res = (VkExternalImageFormatPropertiesNV*)pool->alloc(sizeof(const VkExternalImageFormatPropertiesNV));
    deepcopy_VkExternalImageFormatPropertiesNV(pool, toUnbox, res);
    handlemap_VkExternalImageFormatPropertiesNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_external_memory
VkExternalMemoryImageCreateInfoNV* unbox_VkExternalMemoryImageCreateInfoNV(
    Pool* pool,
    const VkExternalMemoryImageCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalMemoryImageCreateInfoNV* res = (VkExternalMemoryImageCreateInfoNV*)pool->alloc(sizeof(const VkExternalMemoryImageCreateInfoNV));
    deepcopy_VkExternalMemoryImageCreateInfoNV(pool, toUnbox, res);
    handlemap_VkExternalMemoryImageCreateInfoNV(&unboxMapping, res);
    return res;
}

VkExportMemoryAllocateInfoNV* unbox_VkExportMemoryAllocateInfoNV(
    Pool* pool,
    const VkExportMemoryAllocateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportMemoryAllocateInfoNV* res = (VkExportMemoryAllocateInfoNV*)pool->alloc(sizeof(const VkExportMemoryAllocateInfoNV));
    deepcopy_VkExportMemoryAllocateInfoNV(pool, toUnbox, res);
    handlemap_VkExportMemoryAllocateInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_external_memory_win32
VkImportMemoryWin32HandleInfoNV* unbox_VkImportMemoryWin32HandleInfoNV(
    Pool* pool,
    const VkImportMemoryWin32HandleInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportMemoryWin32HandleInfoNV* res = (VkImportMemoryWin32HandleInfoNV*)pool->alloc(sizeof(const VkImportMemoryWin32HandleInfoNV));
    deepcopy_VkImportMemoryWin32HandleInfoNV(pool, toUnbox, res);
    handlemap_VkImportMemoryWin32HandleInfoNV(&unboxMapping, res);
    return res;
}

VkExportMemoryWin32HandleInfoNV* unbox_VkExportMemoryWin32HandleInfoNV(
    Pool* pool,
    const VkExportMemoryWin32HandleInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExportMemoryWin32HandleInfoNV* res = (VkExportMemoryWin32HandleInfoNV*)pool->alloc(sizeof(const VkExportMemoryWin32HandleInfoNV));
    deepcopy_VkExportMemoryWin32HandleInfoNV(pool, toUnbox, res);
    handlemap_VkExportMemoryWin32HandleInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_win32_keyed_mutex
VkWin32KeyedMutexAcquireReleaseInfoNV* unbox_VkWin32KeyedMutexAcquireReleaseInfoNV(
    Pool* pool,
    const VkWin32KeyedMutexAcquireReleaseInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkWin32KeyedMutexAcquireReleaseInfoNV* res = (VkWin32KeyedMutexAcquireReleaseInfoNV*)pool->alloc(sizeof(const VkWin32KeyedMutexAcquireReleaseInfoNV));
    deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(pool, toUnbox, res);
    handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_validation_flags
VkValidationFlagsEXT* unbox_VkValidationFlagsEXT(
    Pool* pool,
    const VkValidationFlagsEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkValidationFlagsEXT* res = (VkValidationFlagsEXT*)pool->alloc(sizeof(const VkValidationFlagsEXT));
    deepcopy_VkValidationFlagsEXT(pool, toUnbox, res);
    handlemap_VkValidationFlagsEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NN_vi_surface
VkViSurfaceCreateInfoNN* unbox_VkViSurfaceCreateInfoNN(
    Pool* pool,
    const VkViSurfaceCreateInfoNN* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkViSurfaceCreateInfoNN* res = (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
    deepcopy_VkViSurfaceCreateInfoNN(pool, toUnbox, res);
    handlemap_VkViSurfaceCreateInfoNN(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_conditional_rendering
VkConditionalRenderingBeginInfoEXT* unbox_VkConditionalRenderingBeginInfoEXT(
    Pool* pool,
    const VkConditionalRenderingBeginInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkConditionalRenderingBeginInfoEXT* res = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(sizeof(const VkConditionalRenderingBeginInfoEXT));
    deepcopy_VkConditionalRenderingBeginInfoEXT(pool, toUnbox, res);
    handlemap_VkConditionalRenderingBeginInfoEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceConditionalRenderingFeaturesEXT* unbox_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    Pool* pool,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceConditionalRenderingFeaturesEXT* res = (VkPhysicalDeviceConditionalRenderingFeaturesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceConditionalRenderingFeaturesEXT));
    deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(&unboxMapping, res);
    return res;
}

VkCommandBufferInheritanceConditionalRenderingInfoEXT* unbox_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    Pool* pool,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCommandBufferInheritanceConditionalRenderingInfoEXT* res = (VkCommandBufferInheritanceConditionalRenderingInfoEXT*)pool->alloc(sizeof(const VkCommandBufferInheritanceConditionalRenderingInfoEXT));
    deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(pool, toUnbox, res);
    handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NVX_device_generated_commands
VkDeviceGeneratedCommandsFeaturesNVX* unbox_VkDeviceGeneratedCommandsFeaturesNVX(
    Pool* pool,
    const VkDeviceGeneratedCommandsFeaturesNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGeneratedCommandsFeaturesNVX* res = (VkDeviceGeneratedCommandsFeaturesNVX*)pool->alloc(sizeof(const VkDeviceGeneratedCommandsFeaturesNVX));
    deepcopy_VkDeviceGeneratedCommandsFeaturesNVX(pool, toUnbox, res);
    handlemap_VkDeviceGeneratedCommandsFeaturesNVX(&unboxMapping, res);
    return res;
}

VkDeviceGeneratedCommandsLimitsNVX* unbox_VkDeviceGeneratedCommandsLimitsNVX(
    Pool* pool,
    const VkDeviceGeneratedCommandsLimitsNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceGeneratedCommandsLimitsNVX* res = (VkDeviceGeneratedCommandsLimitsNVX*)pool->alloc(sizeof(const VkDeviceGeneratedCommandsLimitsNVX));
    deepcopy_VkDeviceGeneratedCommandsLimitsNVX(pool, toUnbox, res);
    handlemap_VkDeviceGeneratedCommandsLimitsNVX(&unboxMapping, res);
    return res;
}

VkIndirectCommandsTokenNVX* unbox_VkIndirectCommandsTokenNVX(
    Pool* pool,
    const VkIndirectCommandsTokenNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkIndirectCommandsTokenNVX* res = (VkIndirectCommandsTokenNVX*)pool->alloc(sizeof(const VkIndirectCommandsTokenNVX));
    deepcopy_VkIndirectCommandsTokenNVX(pool, toUnbox, res);
    handlemap_VkIndirectCommandsTokenNVX(&unboxMapping, res);
    return res;
}

VkIndirectCommandsLayoutTokenNVX* unbox_VkIndirectCommandsLayoutTokenNVX(
    Pool* pool,
    const VkIndirectCommandsLayoutTokenNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkIndirectCommandsLayoutTokenNVX* res = (VkIndirectCommandsLayoutTokenNVX*)pool->alloc(sizeof(const VkIndirectCommandsLayoutTokenNVX));
    deepcopy_VkIndirectCommandsLayoutTokenNVX(pool, toUnbox, res);
    handlemap_VkIndirectCommandsLayoutTokenNVX(&unboxMapping, res);
    return res;
}

VkIndirectCommandsLayoutCreateInfoNVX* unbox_VkIndirectCommandsLayoutCreateInfoNVX(
    Pool* pool,
    const VkIndirectCommandsLayoutCreateInfoNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkIndirectCommandsLayoutCreateInfoNVX* res = (VkIndirectCommandsLayoutCreateInfoNVX*)pool->alloc(sizeof(const VkIndirectCommandsLayoutCreateInfoNVX));
    deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(pool, toUnbox, res);
    handlemap_VkIndirectCommandsLayoutCreateInfoNVX(&unboxMapping, res);
    return res;
}

VkCmdProcessCommandsInfoNVX* unbox_VkCmdProcessCommandsInfoNVX(
    Pool* pool,
    const VkCmdProcessCommandsInfoNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCmdProcessCommandsInfoNVX* res = (VkCmdProcessCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdProcessCommandsInfoNVX));
    deepcopy_VkCmdProcessCommandsInfoNVX(pool, toUnbox, res);
    handlemap_VkCmdProcessCommandsInfoNVX(&unboxMapping, res);
    return res;
}

VkCmdReserveSpaceForCommandsInfoNVX* unbox_VkCmdReserveSpaceForCommandsInfoNVX(
    Pool* pool,
    const VkCmdReserveSpaceForCommandsInfoNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCmdReserveSpaceForCommandsInfoNVX* res = (VkCmdReserveSpaceForCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdReserveSpaceForCommandsInfoNVX));
    deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(pool, toUnbox, res);
    handlemap_VkCmdReserveSpaceForCommandsInfoNVX(&unboxMapping, res);
    return res;
}

VkObjectTableCreateInfoNVX* unbox_VkObjectTableCreateInfoNVX(
    Pool* pool,
    const VkObjectTableCreateInfoNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTableCreateInfoNVX* res = (VkObjectTableCreateInfoNVX*)pool->alloc(sizeof(const VkObjectTableCreateInfoNVX));
    deepcopy_VkObjectTableCreateInfoNVX(pool, toUnbox, res);
    handlemap_VkObjectTableCreateInfoNVX(&unboxMapping, res);
    return res;
}

VkObjectTableEntryNVX* unbox_VkObjectTableEntryNVX(
    Pool* pool,
    const VkObjectTableEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTableEntryNVX* res = (VkObjectTableEntryNVX*)pool->alloc(sizeof(const VkObjectTableEntryNVX));
    deepcopy_VkObjectTableEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTableEntryNVX(&unboxMapping, res);
    return res;
}

VkObjectTablePipelineEntryNVX* unbox_VkObjectTablePipelineEntryNVX(
    Pool* pool,
    const VkObjectTablePipelineEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTablePipelineEntryNVX* res = (VkObjectTablePipelineEntryNVX*)pool->alloc(sizeof(const VkObjectTablePipelineEntryNVX));
    deepcopy_VkObjectTablePipelineEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTablePipelineEntryNVX(&unboxMapping, res);
    return res;
}

VkObjectTableDescriptorSetEntryNVX* unbox_VkObjectTableDescriptorSetEntryNVX(
    Pool* pool,
    const VkObjectTableDescriptorSetEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTableDescriptorSetEntryNVX* res = (VkObjectTableDescriptorSetEntryNVX*)pool->alloc(sizeof(const VkObjectTableDescriptorSetEntryNVX));
    deepcopy_VkObjectTableDescriptorSetEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTableDescriptorSetEntryNVX(&unboxMapping, res);
    return res;
}

VkObjectTableVertexBufferEntryNVX* unbox_VkObjectTableVertexBufferEntryNVX(
    Pool* pool,
    const VkObjectTableVertexBufferEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTableVertexBufferEntryNVX* res = (VkObjectTableVertexBufferEntryNVX*)pool->alloc(sizeof(const VkObjectTableVertexBufferEntryNVX));
    deepcopy_VkObjectTableVertexBufferEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTableVertexBufferEntryNVX(&unboxMapping, res);
    return res;
}

VkObjectTableIndexBufferEntryNVX* unbox_VkObjectTableIndexBufferEntryNVX(
    Pool* pool,
    const VkObjectTableIndexBufferEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTableIndexBufferEntryNVX* res = (VkObjectTableIndexBufferEntryNVX*)pool->alloc(sizeof(const VkObjectTableIndexBufferEntryNVX));
    deepcopy_VkObjectTableIndexBufferEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTableIndexBufferEntryNVX(&unboxMapping, res);
    return res;
}

VkObjectTablePushConstantEntryNVX* unbox_VkObjectTablePushConstantEntryNVX(
    Pool* pool,
    const VkObjectTablePushConstantEntryNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkObjectTablePushConstantEntryNVX* res = (VkObjectTablePushConstantEntryNVX*)pool->alloc(sizeof(const VkObjectTablePushConstantEntryNVX));
    deepcopy_VkObjectTablePushConstantEntryNVX(pool, toUnbox, res);
    handlemap_VkObjectTablePushConstantEntryNVX(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_clip_space_w_scaling
VkViewportWScalingNV* unbox_VkViewportWScalingNV(
    Pool* pool,
    const VkViewportWScalingNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkViewportWScalingNV* res = (VkViewportWScalingNV*)pool->alloc(sizeof(const VkViewportWScalingNV));
    deepcopy_VkViewportWScalingNV(pool, toUnbox, res);
    handlemap_VkViewportWScalingNV(&unboxMapping, res);
    return res;
}

VkPipelineViewportWScalingStateCreateInfoNV* unbox_VkPipelineViewportWScalingStateCreateInfoNV(
    Pool* pool,
    const VkPipelineViewportWScalingStateCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineViewportWScalingStateCreateInfoNV* res = (VkPipelineViewportWScalingStateCreateInfoNV*)pool->alloc(sizeof(const VkPipelineViewportWScalingStateCreateInfoNV));
    deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(pool, toUnbox, res);
    handlemap_VkPipelineViewportWScalingStateCreateInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
VkSurfaceCapabilities2EXT* unbox_VkSurfaceCapabilities2EXT(
    Pool* pool,
    const VkSurfaceCapabilities2EXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSurfaceCapabilities2EXT* res = (VkSurfaceCapabilities2EXT*)pool->alloc(sizeof(const VkSurfaceCapabilities2EXT));
    deepcopy_VkSurfaceCapabilities2EXT(pool, toUnbox, res);
    handlemap_VkSurfaceCapabilities2EXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_display_control
VkDisplayPowerInfoEXT* unbox_VkDisplayPowerInfoEXT(
    Pool* pool,
    const VkDisplayPowerInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayPowerInfoEXT* res = (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
    deepcopy_VkDisplayPowerInfoEXT(pool, toUnbox, res);
    handlemap_VkDisplayPowerInfoEXT(&unboxMapping, res);
    return res;
}

VkDeviceEventInfoEXT* unbox_VkDeviceEventInfoEXT(
    Pool* pool,
    const VkDeviceEventInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceEventInfoEXT* res = (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
    deepcopy_VkDeviceEventInfoEXT(pool, toUnbox, res);
    handlemap_VkDeviceEventInfoEXT(&unboxMapping, res);
    return res;
}

VkDisplayEventInfoEXT* unbox_VkDisplayEventInfoEXT(
    Pool* pool,
    const VkDisplayEventInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDisplayEventInfoEXT* res = (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
    deepcopy_VkDisplayEventInfoEXT(pool, toUnbox, res);
    handlemap_VkDisplayEventInfoEXT(&unboxMapping, res);
    return res;
}

VkSwapchainCounterCreateInfoEXT* unbox_VkSwapchainCounterCreateInfoEXT(
    Pool* pool,
    const VkSwapchainCounterCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSwapchainCounterCreateInfoEXT* res = (VkSwapchainCounterCreateInfoEXT*)pool->alloc(sizeof(const VkSwapchainCounterCreateInfoEXT));
    deepcopy_VkSwapchainCounterCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkSwapchainCounterCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_GOOGLE_display_timing
VkRefreshCycleDurationGOOGLE* unbox_VkRefreshCycleDurationGOOGLE(
    Pool* pool,
    const VkRefreshCycleDurationGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRefreshCycleDurationGOOGLE* res = (VkRefreshCycleDurationGOOGLE*)pool->alloc(sizeof(const VkRefreshCycleDurationGOOGLE));
    deepcopy_VkRefreshCycleDurationGOOGLE(pool, toUnbox, res);
    handlemap_VkRefreshCycleDurationGOOGLE(&unboxMapping, res);
    return res;
}

VkPastPresentationTimingGOOGLE* unbox_VkPastPresentationTimingGOOGLE(
    Pool* pool,
    const VkPastPresentationTimingGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPastPresentationTimingGOOGLE* res = (VkPastPresentationTimingGOOGLE*)pool->alloc(sizeof(const VkPastPresentationTimingGOOGLE));
    deepcopy_VkPastPresentationTimingGOOGLE(pool, toUnbox, res);
    handlemap_VkPastPresentationTimingGOOGLE(&unboxMapping, res);
    return res;
}

VkPresentTimeGOOGLE* unbox_VkPresentTimeGOOGLE(
    Pool* pool,
    const VkPresentTimeGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPresentTimeGOOGLE* res = (VkPresentTimeGOOGLE*)pool->alloc(sizeof(const VkPresentTimeGOOGLE));
    deepcopy_VkPresentTimeGOOGLE(pool, toUnbox, res);
    handlemap_VkPresentTimeGOOGLE(&unboxMapping, res);
    return res;
}

VkPresentTimesInfoGOOGLE* unbox_VkPresentTimesInfoGOOGLE(
    Pool* pool,
    const VkPresentTimesInfoGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPresentTimesInfoGOOGLE* res = (VkPresentTimesInfoGOOGLE*)pool->alloc(sizeof(const VkPresentTimesInfoGOOGLE));
    deepcopy_VkPresentTimesInfoGOOGLE(pool, toUnbox, res);
    handlemap_VkPresentTimesInfoGOOGLE(&unboxMapping, res);
    return res;
}

#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
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* unbox_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    Pool* pool,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* res = (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*)pool->alloc(sizeof(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX));
    deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_viewport_swizzle
VkViewportSwizzleNV* unbox_VkViewportSwizzleNV(
    Pool* pool,
    const VkViewportSwizzleNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkViewportSwizzleNV* res = (VkViewportSwizzleNV*)pool->alloc(sizeof(const VkViewportSwizzleNV));
    deepcopy_VkViewportSwizzleNV(pool, toUnbox, res);
    handlemap_VkViewportSwizzleNV(&unboxMapping, res);
    return res;
}

VkPipelineViewportSwizzleStateCreateInfoNV* unbox_VkPipelineViewportSwizzleStateCreateInfoNV(
    Pool* pool,
    const VkPipelineViewportSwizzleStateCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineViewportSwizzleStateCreateInfoNV* res = (VkPipelineViewportSwizzleStateCreateInfoNV*)pool->alloc(sizeof(const VkPipelineViewportSwizzleStateCreateInfoNV));
    deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(pool, toUnbox, res);
    handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_discard_rectangles
VkPhysicalDeviceDiscardRectanglePropertiesEXT* unbox_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceDiscardRectanglePropertiesEXT* res = (VkPhysicalDeviceDiscardRectanglePropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceDiscardRectanglePropertiesEXT));
    deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(&unboxMapping, res);
    return res;
}

VkPipelineDiscardRectangleStateCreateInfoEXT* unbox_VkPipelineDiscardRectangleStateCreateInfoEXT(
    Pool* pool,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineDiscardRectangleStateCreateInfoEXT* res = (VkPipelineDiscardRectangleStateCreateInfoEXT*)pool->alloc(sizeof(const VkPipelineDiscardRectangleStateCreateInfoEXT));
    deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_conservative_rasterization
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* unbox_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* res = (VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT));
    deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(&unboxMapping, res);
    return res;
}

VkPipelineRasterizationConservativeStateCreateInfoEXT* unbox_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    Pool* pool,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineRasterizationConservativeStateCreateInfoEXT* res = (VkPipelineRasterizationConservativeStateCreateInfoEXT*)pool->alloc(sizeof(const VkPipelineRasterizationConservativeStateCreateInfoEXT));
    deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
VkXYColorEXT* unbox_VkXYColorEXT(
    Pool* pool,
    const VkXYColorEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkXYColorEXT* res = (VkXYColorEXT*)pool->alloc(sizeof(const VkXYColorEXT));
    deepcopy_VkXYColorEXT(pool, toUnbox, res);
    handlemap_VkXYColorEXT(&unboxMapping, res);
    return res;
}

VkHdrMetadataEXT* unbox_VkHdrMetadataEXT(
    Pool* pool,
    const VkHdrMetadataEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkHdrMetadataEXT* res = (VkHdrMetadataEXT*)pool->alloc(sizeof(const VkHdrMetadataEXT));
    deepcopy_VkHdrMetadataEXT(pool, toUnbox, res);
    handlemap_VkHdrMetadataEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_MVK_ios_surface
VkIOSSurfaceCreateInfoMVK* unbox_VkIOSSurfaceCreateInfoMVK(
    Pool* pool,
    const VkIOSSurfaceCreateInfoMVK* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkIOSSurfaceCreateInfoMVK* res = (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
    deepcopy_VkIOSSurfaceCreateInfoMVK(pool, toUnbox, res);
    handlemap_VkIOSSurfaceCreateInfoMVK(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_MVK_macos_surface
VkMacOSSurfaceCreateInfoMVK* unbox_VkMacOSSurfaceCreateInfoMVK(
    Pool* pool,
    const VkMacOSSurfaceCreateInfoMVK* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMacOSSurfaceCreateInfoMVK* res = (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
    deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, toUnbox, res);
    handlemap_VkMacOSSurfaceCreateInfoMVK(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
VkDebugUtilsObjectNameInfoEXT* unbox_VkDebugUtilsObjectNameInfoEXT(
    Pool* pool,
    const VkDebugUtilsObjectNameInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugUtilsObjectNameInfoEXT* res = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectNameInfoEXT));
    deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugUtilsObjectNameInfoEXT(&unboxMapping, res);
    return res;
}

VkDebugUtilsObjectTagInfoEXT* unbox_VkDebugUtilsObjectTagInfoEXT(
    Pool* pool,
    const VkDebugUtilsObjectTagInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugUtilsObjectTagInfoEXT* res = (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
    deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugUtilsObjectTagInfoEXT(&unboxMapping, res);
    return res;
}

VkDebugUtilsLabelEXT* unbox_VkDebugUtilsLabelEXT(
    Pool* pool,
    const VkDebugUtilsLabelEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugUtilsLabelEXT* res = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
    deepcopy_VkDebugUtilsLabelEXT(pool, toUnbox, res);
    handlemap_VkDebugUtilsLabelEXT(&unboxMapping, res);
    return res;
}

VkDebugUtilsMessengerCallbackDataEXT* unbox_VkDebugUtilsMessengerCallbackDataEXT(
    Pool* pool,
    const VkDebugUtilsMessengerCallbackDataEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugUtilsMessengerCallbackDataEXT* res = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
    deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, toUnbox, res);
    handlemap_VkDebugUtilsMessengerCallbackDataEXT(&unboxMapping, res);
    return res;
}

VkDebugUtilsMessengerCreateInfoEXT* unbox_VkDebugUtilsMessengerCreateInfoEXT(
    Pool* pool,
    const VkDebugUtilsMessengerCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDebugUtilsMessengerCreateInfoEXT* res = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
    deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkDebugUtilsMessengerCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
VkAndroidHardwareBufferUsageANDROID* unbox_VkAndroidHardwareBufferUsageANDROID(
    Pool* pool,
    const VkAndroidHardwareBufferUsageANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAndroidHardwareBufferUsageANDROID* res = (VkAndroidHardwareBufferUsageANDROID*)pool->alloc(sizeof(const VkAndroidHardwareBufferUsageANDROID));
    deepcopy_VkAndroidHardwareBufferUsageANDROID(pool, toUnbox, res);
    handlemap_VkAndroidHardwareBufferUsageANDROID(&unboxMapping, res);
    return res;
}

VkAndroidHardwareBufferPropertiesANDROID* unbox_VkAndroidHardwareBufferPropertiesANDROID(
    Pool* pool,
    const VkAndroidHardwareBufferPropertiesANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAndroidHardwareBufferPropertiesANDROID* res = (VkAndroidHardwareBufferPropertiesANDROID*)pool->alloc(sizeof(const VkAndroidHardwareBufferPropertiesANDROID));
    deepcopy_VkAndroidHardwareBufferPropertiesANDROID(pool, toUnbox, res);
    handlemap_VkAndroidHardwareBufferPropertiesANDROID(&unboxMapping, res);
    return res;
}

VkAndroidHardwareBufferFormatPropertiesANDROID* unbox_VkAndroidHardwareBufferFormatPropertiesANDROID(
    Pool* pool,
    const VkAndroidHardwareBufferFormatPropertiesANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAndroidHardwareBufferFormatPropertiesANDROID* res = (VkAndroidHardwareBufferFormatPropertiesANDROID*)pool->alloc(sizeof(const VkAndroidHardwareBufferFormatPropertiesANDROID));
    deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(pool, toUnbox, res);
    handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(&unboxMapping, res);
    return res;
}

VkImportAndroidHardwareBufferInfoANDROID* unbox_VkImportAndroidHardwareBufferInfoANDROID(
    Pool* pool,
    const VkImportAndroidHardwareBufferInfoANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportAndroidHardwareBufferInfoANDROID* res = (VkImportAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkImportAndroidHardwareBufferInfoANDROID));
    deepcopy_VkImportAndroidHardwareBufferInfoANDROID(pool, toUnbox, res);
    handlemap_VkImportAndroidHardwareBufferInfoANDROID(&unboxMapping, res);
    return res;
}

VkMemoryGetAndroidHardwareBufferInfoANDROID* unbox_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    Pool* pool,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryGetAndroidHardwareBufferInfoANDROID* res = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
    deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, toUnbox, res);
    handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(&unboxMapping, res);
    return res;
}

VkExternalFormatANDROID* unbox_VkExternalFormatANDROID(
    Pool* pool,
    const VkExternalFormatANDROID* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkExternalFormatANDROID* res = (VkExternalFormatANDROID*)pool->alloc(sizeof(const VkExternalFormatANDROID));
    deepcopy_VkExternalFormatANDROID(pool, toUnbox, res);
    handlemap_VkExternalFormatANDROID(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_sampler_filter_minmax
VkSamplerReductionModeCreateInfoEXT* unbox_VkSamplerReductionModeCreateInfoEXT(
    Pool* pool,
    const VkSamplerReductionModeCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSamplerReductionModeCreateInfoEXT* res = (VkSamplerReductionModeCreateInfoEXT*)pool->alloc(sizeof(const VkSamplerReductionModeCreateInfoEXT));
    deepcopy_VkSamplerReductionModeCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkSamplerReductionModeCreateInfoEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* unbox_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* res = (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT));
    deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_gpu_shader_int16
#endif
#ifdef VK_AMD_mixed_attachment_samples
#endif
#ifdef VK_AMD_shader_fragment_mask
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
VkSampleLocationEXT* unbox_VkSampleLocationEXT(
    Pool* pool,
    const VkSampleLocationEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSampleLocationEXT* res = (VkSampleLocationEXT*)pool->alloc(sizeof(const VkSampleLocationEXT));
    deepcopy_VkSampleLocationEXT(pool, toUnbox, res);
    handlemap_VkSampleLocationEXT(&unboxMapping, res);
    return res;
}

VkSampleLocationsInfoEXT* unbox_VkSampleLocationsInfoEXT(
    Pool* pool,
    const VkSampleLocationsInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSampleLocationsInfoEXT* res = (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
    deepcopy_VkSampleLocationsInfoEXT(pool, toUnbox, res);
    handlemap_VkSampleLocationsInfoEXT(&unboxMapping, res);
    return res;
}

VkAttachmentSampleLocationsEXT* unbox_VkAttachmentSampleLocationsEXT(
    Pool* pool,
    const VkAttachmentSampleLocationsEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkAttachmentSampleLocationsEXT* res = (VkAttachmentSampleLocationsEXT*)pool->alloc(sizeof(const VkAttachmentSampleLocationsEXT));
    deepcopy_VkAttachmentSampleLocationsEXT(pool, toUnbox, res);
    handlemap_VkAttachmentSampleLocationsEXT(&unboxMapping, res);
    return res;
}

VkSubpassSampleLocationsEXT* unbox_VkSubpassSampleLocationsEXT(
    Pool* pool,
    const VkSubpassSampleLocationsEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkSubpassSampleLocationsEXT* res = (VkSubpassSampleLocationsEXT*)pool->alloc(sizeof(const VkSubpassSampleLocationsEXT));
    deepcopy_VkSubpassSampleLocationsEXT(pool, toUnbox, res);
    handlemap_VkSubpassSampleLocationsEXT(&unboxMapping, res);
    return res;
}

VkRenderPassSampleLocationsBeginInfoEXT* unbox_VkRenderPassSampleLocationsBeginInfoEXT(
    Pool* pool,
    const VkRenderPassSampleLocationsBeginInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkRenderPassSampleLocationsBeginInfoEXT* res = (VkRenderPassSampleLocationsBeginInfoEXT*)pool->alloc(sizeof(const VkRenderPassSampleLocationsBeginInfoEXT));
    deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(pool, toUnbox, res);
    handlemap_VkRenderPassSampleLocationsBeginInfoEXT(&unboxMapping, res);
    return res;
}

VkPipelineSampleLocationsStateCreateInfoEXT* unbox_VkPipelineSampleLocationsStateCreateInfoEXT(
    Pool* pool,
    const VkPipelineSampleLocationsStateCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineSampleLocationsStateCreateInfoEXT* res = (VkPipelineSampleLocationsStateCreateInfoEXT*)pool->alloc(sizeof(const VkPipelineSampleLocationsStateCreateInfoEXT));
    deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceSampleLocationsPropertiesEXT* unbox_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceSampleLocationsPropertiesEXT* res = (VkPhysicalDeviceSampleLocationsPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceSampleLocationsPropertiesEXT));
    deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(&unboxMapping, res);
    return res;
}

VkMultisamplePropertiesEXT* unbox_VkMultisamplePropertiesEXT(
    Pool* pool,
    const VkMultisamplePropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMultisamplePropertiesEXT* res = (VkMultisamplePropertiesEXT*)pool->alloc(sizeof(const VkMultisamplePropertiesEXT));
    deepcopy_VkMultisamplePropertiesEXT(pool, toUnbox, res);
    handlemap_VkMultisamplePropertiesEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_blend_operation_advanced
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* unbox_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    Pool* pool,
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* res = (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT));
    deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* unbox_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* res = (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT));
    deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(&unboxMapping, res);
    return res;
}

VkPipelineColorBlendAdvancedStateCreateInfoEXT* unbox_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    Pool* pool,
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineColorBlendAdvancedStateCreateInfoEXT* res = (VkPipelineColorBlendAdvancedStateCreateInfoEXT*)pool->alloc(sizeof(const VkPipelineColorBlendAdvancedStateCreateInfoEXT));
    deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_fragment_coverage_to_color
VkPipelineCoverageToColorStateCreateInfoNV* unbox_VkPipelineCoverageToColorStateCreateInfoNV(
    Pool* pool,
    const VkPipelineCoverageToColorStateCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineCoverageToColorStateCreateInfoNV* res = (VkPipelineCoverageToColorStateCreateInfoNV*)pool->alloc(sizeof(const VkPipelineCoverageToColorStateCreateInfoNV));
    deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(pool, toUnbox, res);
    handlemap_VkPipelineCoverageToColorStateCreateInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_framebuffer_mixed_samples
VkPipelineCoverageModulationStateCreateInfoNV* unbox_VkPipelineCoverageModulationStateCreateInfoNV(
    Pool* pool,
    const VkPipelineCoverageModulationStateCreateInfoNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineCoverageModulationStateCreateInfoNV* res = (VkPipelineCoverageModulationStateCreateInfoNV*)pool->alloc(sizeof(const VkPipelineCoverageModulationStateCreateInfoNV));
    deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(pool, toUnbox, res);
    handlemap_VkPipelineCoverageModulationStateCreateInfoNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_validation_cache
VkValidationCacheCreateInfoEXT* unbox_VkValidationCacheCreateInfoEXT(
    Pool* pool,
    const VkValidationCacheCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkValidationCacheCreateInfoEXT* res = (VkValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkValidationCacheCreateInfoEXT));
    deepcopy_VkValidationCacheCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkValidationCacheCreateInfoEXT(&unboxMapping, res);
    return res;
}

VkShaderModuleValidationCacheCreateInfoEXT* unbox_VkShaderModuleValidationCacheCreateInfoEXT(
    Pool* pool,
    const VkShaderModuleValidationCacheCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkShaderModuleValidationCacheCreateInfoEXT* res = (VkShaderModuleValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkShaderModuleValidationCacheCreateInfoEXT));
    deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkShaderModuleValidationCacheCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_descriptor_indexing
VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* unbox_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
    Pool* pool,
    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* res = (VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*)pool->alloc(sizeof(const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT));
    deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceDescriptorIndexingFeaturesEXT* unbox_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
    Pool* pool,
    const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* res = (VkPhysicalDeviceDescriptorIndexingFeaturesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceDescriptorIndexingFeaturesEXT));
    deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceDescriptorIndexingPropertiesEXT* unbox_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* res = (VkPhysicalDeviceDescriptorIndexingPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceDescriptorIndexingPropertiesEXT));
    deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(&unboxMapping, res);
    return res;
}

VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* unbox_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
    Pool* pool,
    const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* res = (VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*)pool->alloc(sizeof(const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT));
    deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(pool, toUnbox, res);
    handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(&unboxMapping, res);
    return res;
}

VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* unbox_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
    Pool* pool,
    const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* res = (VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*)pool->alloc(sizeof(const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT));
    deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(pool, toUnbox, res);
    handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_EXT_global_priority
VkDeviceQueueGlobalPriorityCreateInfoEXT* unbox_VkDeviceQueueGlobalPriorityCreateInfoEXT(
    Pool* pool,
    const VkDeviceQueueGlobalPriorityCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkDeviceQueueGlobalPriorityCreateInfoEXT* res = (VkDeviceQueueGlobalPriorityCreateInfoEXT*)pool->alloc(sizeof(const VkDeviceQueueGlobalPriorityCreateInfoEXT));
    deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_external_memory_host
VkImportMemoryHostPointerInfoEXT* unbox_VkImportMemoryHostPointerInfoEXT(
    Pool* pool,
    const VkImportMemoryHostPointerInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportMemoryHostPointerInfoEXT* res = (VkImportMemoryHostPointerInfoEXT*)pool->alloc(sizeof(const VkImportMemoryHostPointerInfoEXT));
    deepcopy_VkImportMemoryHostPointerInfoEXT(pool, toUnbox, res);
    handlemap_VkImportMemoryHostPointerInfoEXT(&unboxMapping, res);
    return res;
}

VkMemoryHostPointerPropertiesEXT* unbox_VkMemoryHostPointerPropertiesEXT(
    Pool* pool,
    const VkMemoryHostPointerPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkMemoryHostPointerPropertiesEXT* res = (VkMemoryHostPointerPropertiesEXT*)pool->alloc(sizeof(const VkMemoryHostPointerPropertiesEXT));
    deepcopy_VkMemoryHostPointerPropertiesEXT(pool, toUnbox, res);
    handlemap_VkMemoryHostPointerPropertiesEXT(&unboxMapping, res);
    return res;
}

VkPhysicalDeviceExternalMemoryHostPropertiesEXT* unbox_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* res = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT));
    deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_shader_core_properties
VkPhysicalDeviceShaderCorePropertiesAMD* unbox_VkPhysicalDeviceShaderCorePropertiesAMD(
    Pool* pool,
    const VkPhysicalDeviceShaderCorePropertiesAMD* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceShaderCorePropertiesAMD* res = (VkPhysicalDeviceShaderCorePropertiesAMD*)pool->alloc(sizeof(const VkPhysicalDeviceShaderCorePropertiesAMD));
    deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_EXT_vertex_attribute_divisor
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* unbox_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    Pool* pool,
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* res = (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)pool->alloc(sizeof(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT));
    deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(pool, toUnbox, res);
    handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(&unboxMapping, res);
    return res;
}

VkVertexInputBindingDivisorDescriptionEXT* unbox_VkVertexInputBindingDivisorDescriptionEXT(
    Pool* pool,
    const VkVertexInputBindingDivisorDescriptionEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkVertexInputBindingDivisorDescriptionEXT* res = (VkVertexInputBindingDivisorDescriptionEXT*)pool->alloc(sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
    deepcopy_VkVertexInputBindingDivisorDescriptionEXT(pool, toUnbox, res);
    handlemap_VkVertexInputBindingDivisorDescriptionEXT(&unboxMapping, res);
    return res;
}

VkPipelineVertexInputDivisorStateCreateInfoEXT* unbox_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    Pool* pool,
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkPipelineVertexInputDivisorStateCreateInfoEXT* res = (VkPipelineVertexInputDivisorStateCreateInfoEXT*)pool->alloc(sizeof(const VkPipelineVertexInputDivisorStateCreateInfoEXT));
    deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(pool, toUnbox, res);
    handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
VkQueueFamilyCheckpointPropertiesNV* unbox_VkQueueFamilyCheckpointPropertiesNV(
    Pool* pool,
    const VkQueueFamilyCheckpointPropertiesNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkQueueFamilyCheckpointPropertiesNV* res = (VkQueueFamilyCheckpointPropertiesNV*)pool->alloc(sizeof(const VkQueueFamilyCheckpointPropertiesNV));
    deepcopy_VkQueueFamilyCheckpointPropertiesNV(pool, toUnbox, res);
    handlemap_VkQueueFamilyCheckpointPropertiesNV(&unboxMapping, res);
    return res;
}

VkCheckpointDataNV* unbox_VkCheckpointDataNV(
    Pool* pool,
    const VkCheckpointDataNV* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkCheckpointDataNV* res = (VkCheckpointDataNV*)pool->alloc(sizeof(const VkCheckpointDataNV));
    deepcopy_VkCheckpointDataNV(pool, toUnbox, res);
    handlemap_VkCheckpointDataNV(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_GOOGLE_address_space
#endif
#ifdef VK_GOOGLE_color_buffer
VkImportColorBufferGOOGLE* unbox_VkImportColorBufferGOOGLE(
    Pool* pool,
    const VkImportColorBufferGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportColorBufferGOOGLE* res = (VkImportColorBufferGOOGLE*)pool->alloc(sizeof(const VkImportColorBufferGOOGLE));
    deepcopy_VkImportColorBufferGOOGLE(pool, toUnbox, res);
    handlemap_VkImportColorBufferGOOGLE(&unboxMapping, res);
    return res;
}

VkImportPhysicalAddressGOOGLE* unbox_VkImportPhysicalAddressGOOGLE(
    Pool* pool,
    const VkImportPhysicalAddressGOOGLE* toUnbox)
{
    BoxedHandleUnwrapMapping unboxMapping;
    VkImportPhysicalAddressGOOGLE* res = (VkImportPhysicalAddressGOOGLE*)pool->alloc(sizeof(const VkImportPhysicalAddressGOOGLE));
    deepcopy_VkImportPhysicalAddressGOOGLE(pool, toUnbox, res);
    handlemap_VkImportPhysicalAddressGOOGLE(&unboxMapping, res);
    return res;
}

#endif
#ifdef VK_GOOGLE_sized_descriptor_update_template
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
#ifdef VK_GOOGLE_create_resources_with_requirements
#endif

} // namespace goldfish_vk