xref: /device/generic/vulkan-cereal/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.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_marshaling
//
// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
//
// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
// $CEREAL_OUTPUT_DIR
//

#include "goldfish_vk_marshaling.h"

#include <string.h>

#include "goldfish_vk_extension_structs.h"
#include "goldfish_vk_private_defs.h"

namespace gfxstream {
namespace vk {

void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                              const void* structExtension);

void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                                void* structExtension_out);

#ifdef VK_VERSION_1_0
void marshal_VkExtent2D(VulkanStream* vkStream, VkStructureType rootType,
                        const VkExtent2D* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
}

void unmarshal_VkExtent2D(VulkanStream* vkStream, VkStructureType rootType,
                          VkExtent2D* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
}

void marshal_VkExtent3D(VulkanStream* vkStream, VkStructureType rootType,
                        const VkExtent3D* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
}

void unmarshal_VkExtent3D(VulkanStream* vkStream, VkStructureType rootType,
                          VkExtent3D* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
}

void marshal_VkOffset2D(VulkanStream* vkStream, VkStructureType rootType,
                        const VkOffset2D* forMarshaling) {
    (void)rootType;
    vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
}

void unmarshal_VkOffset2D(VulkanStream* vkStream, VkStructureType rootType,
                          VkOffset2D* forUnmarshaling) {
    (void)rootType;
    vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
}

void marshal_VkOffset3D(VulkanStream* vkStream, VkStructureType rootType,
                        const VkOffset3D* forMarshaling) {
    (void)rootType;
    vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->z, sizeof(int32_t));
}

void unmarshal_VkOffset3D(VulkanStream* vkStream, VkStructureType rootType,
                          VkOffset3D* forUnmarshaling) {
    (void)rootType;
    vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->z, sizeof(int32_t));
}

void marshal_VkRect2D(VulkanStream* vkStream, VkStructureType rootType,
                      const VkRect2D* forMarshaling) {
    (void)rootType;
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent));
}

void unmarshal_VkRect2D(VulkanStream* vkStream, VkStructureType rootType,
                        VkRect2D* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->offset));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->extent));
}

void marshal_VkBaseInStructure(VulkanStream* vkStream, VkStructureType rootType,
                               const VkBaseInStructure* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}

void unmarshal_VkBaseInStructure(VulkanStream* vkStream, VkStructureType rootType,
                                 VkBaseInStructure* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((VkBaseInStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
}

void marshal_VkBaseOutStructure(VulkanStream* vkStream, VkStructureType rootType,
                                const VkBaseOutStructure* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}

void unmarshal_VkBaseOutStructure(VulkanStream* vkStream, VkStructureType rootType,
                                  VkBaseOutStructure* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((VkBaseOutStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
}

void marshal_VkBufferMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkBufferMemoryBarrier* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkBufferMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                                     VkBufferMemoryBarrier* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkDispatchIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkDispatchIndirectCommand* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->x, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->y, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->z, sizeof(uint32_t));
}

void unmarshal_VkDispatchIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                         VkDispatchIndirectCommand* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->x, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->y, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->z, sizeof(uint32_t));
}

void marshal_VkDrawIndexedIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkDrawIndexedIndirectCommand* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
    vkStream->write((int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
}

void unmarshal_VkDrawIndexedIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                            VkDrawIndexedIndirectCommand* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstIndex, sizeof(uint32_t));
    vkStream->read((int32_t*)&forUnmarshaling->vertexOffset, sizeof(int32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
}

void marshal_VkDrawIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkDrawIndirectCommand* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
}

void unmarshal_VkDrawIndirectCommand(VulkanStream* vkStream, VkStructureType rootType,
                                     VkDrawIndirectCommand* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
}

void marshal_VkImageSubresourceRange(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkImageSubresourceRange* forMarshaling) {
    (void)rootType;
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->write((uint32_t*)&forMarshaling->baseMipLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->levelCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}

void unmarshal_VkImageSubresourceRange(VulkanStream* vkStream, VkStructureType rootType,
                                       VkImageSubresourceRange* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->baseMipLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->levelCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}

void marshal_VkImageMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkImageMemoryBarrier* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    marshal_VkImageSubresourceRange(vkStream, rootType,
                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}

void unmarshal_VkImageMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                                    VkImageMemoryBarrier* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    unmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}

void marshal_VkMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                             const VkMemoryBarrier* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
}

void unmarshal_VkMemoryBarrier(VulkanStream* vkStream, VkStructureType rootType,
                               VkMemoryBarrier* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
}

void marshal_VkPipelineCacheHeaderVersionOne(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPipelineCacheHeaderVersionOne* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
    vkStream->write((VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion,
                    sizeof(VkPipelineCacheHeaderVersion));
    vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
    vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
}

void unmarshal_VkPipelineCacheHeaderVersionOne(VulkanStream* vkStream, VkStructureType rootType,
                                               VkPipelineCacheHeaderVersionOne* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->headerSize, sizeof(uint32_t));
    vkStream->read((VkPipelineCacheHeaderVersion*)&forUnmarshaling->headerVersion,
                   sizeof(VkPipelineCacheHeaderVersion));
    vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
    vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
}

void marshal_VkAllocationCallbacks(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkAllocationCallbacks* forMarshaling) {
    (void)rootType;
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pUserData) {
        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
    }
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->pfnAllocation;
    vkStream->putBe64(cgen_var_1);
    uint64_t cgen_var_2 = (uint64_t)forMarshaling->pfnReallocation;
    vkStream->putBe64(cgen_var_2);
    uint64_t cgen_var_3 = (uint64_t)forMarshaling->pfnFree;
    vkStream->putBe64(cgen_var_3);
    uint64_t cgen_var_4 = (uint64_t)forMarshaling->pfnInternalAllocation;
    vkStream->putBe64(cgen_var_4);
    uint64_t cgen_var_5 = (uint64_t)forMarshaling->pfnInternalFree;
    vkStream->putBe64(cgen_var_5);
}

void unmarshal_VkAllocationCallbacks(VulkanStream* vkStream, VkStructureType rootType,
                                     VkAllocationCallbacks* forUnmarshaling) {
    (void)rootType;
    // WARNING PTR CHECK
    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUserData) {
        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
    }
    forUnmarshaling->pfnAllocation = (PFN_vkAllocationFunction)vkStream->getBe64();
    forUnmarshaling->pfnReallocation = (PFN_vkReallocationFunction)vkStream->getBe64();
    forUnmarshaling->pfnFree = (PFN_vkFreeFunction)vkStream->getBe64();
    forUnmarshaling->pfnInternalAllocation =
        (PFN_vkInternalAllocationNotification)vkStream->getBe64();
    forUnmarshaling->pfnInternalFree = (PFN_vkInternalFreeNotification)vkStream->getBe64();
}

void marshal_VkApplicationInfo(VulkanStream* vkStream, VkStructureType rootType,
                               const VkApplicationInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationName;
        vkStream->putBe64(cgen_var_0);
        if (forMarshaling->pApplicationName) {
            vkStream->putString(forMarshaling->pApplicationName);
        }
    } else {
        vkStream->putString(forMarshaling->pApplicationName);
    }
    vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEngineName;
        vkStream->putBe64(cgen_var_0);
        if (forMarshaling->pEngineName) {
            vkStream->putString(forMarshaling->pEngineName);
        }
    } else {
        vkStream->putString(forMarshaling->pEngineName);
    }
    vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
}

void unmarshal_VkApplicationInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 VkApplicationInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        forUnmarshaling->pApplicationName = (const char*)(uintptr_t)vkStream->getBe64();
        if (forUnmarshaling->pApplicationName) {
            vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
        }
    } else {
        vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        forUnmarshaling->pEngineName = (const char*)(uintptr_t)vkStream->getBe64();
        if (forUnmarshaling->pEngineName) {
            vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
        }
    } else {
        vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
}

void marshal_VkFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                const VkFormatProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures,
                    sizeof(VkFormatFeatureFlags));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures,
                    sizeof(VkFormatFeatureFlags));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->bufferFeatures,
                    sizeof(VkFormatFeatureFlags));
}

void unmarshal_VkFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                  VkFormatProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->linearTilingFeatures,
                   sizeof(VkFormatFeatureFlags));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->optimalTilingFeatures,
                   sizeof(VkFormatFeatureFlags));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->bufferFeatures,
                   sizeof(VkFormatFeatureFlags));
}

void marshal_VkImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkImageFormatProperties* forMarshaling) {
    (void)rootType;
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent));
    vkStream->write((uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxArrayLayers, sizeof(uint32_t));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceSize, sizeof(VkDeviceSize));
}

void unmarshal_VkImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                       VkImageFormatProperties* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->maxExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMipLevels, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxArrayLayers, sizeof(uint32_t));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceSize, sizeof(VkDeviceSize));
}

void marshal_VkInstanceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkInstanceCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pApplicationInfo) {
        marshal_VkApplicationInfo(vkStream, rootType,
                                  (const VkApplicationInfo*)(forMarshaling->pApplicationInfo));
    }
    vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
    saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
    vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
    saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames,
                    forMarshaling->enabledExtensionCount);
}

void unmarshal_VkInstanceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    VkInstanceCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkInstanceCreateFlags*)&forUnmarshaling->flags, sizeof(VkInstanceCreateFlags));
    // WARNING PTR CHECK
    forUnmarshaling->pApplicationInfo = (const VkApplicationInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pApplicationInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pApplicationInfo,
                        sizeof(const VkApplicationInfo));
        unmarshal_VkApplicationInfo(vkStream, rootType,
                                    (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
    vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
}

void marshal_VkMemoryHeap(VulkanStream* vkStream, VkStructureType rootType,
                          const VkMemoryHeap* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
}

void unmarshal_VkMemoryHeap(VulkanStream* vkStream, VkStructureType rootType,
                            VkMemoryHeap* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkMemoryHeapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryHeapFlags));
}

void marshal_VkMemoryType(VulkanStream* vkStream, VkStructureType rootType,
                          const VkMemoryType* forMarshaling) {
    (void)rootType;
    vkStream->write((VkMemoryPropertyFlags*)&forMarshaling->propertyFlags,
                    sizeof(VkMemoryPropertyFlags));
    vkStream->write((uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
}

void unmarshal_VkMemoryType(VulkanStream* vkStream, VkStructureType rootType,
                            VkMemoryType* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkMemoryPropertyFlags*)&forUnmarshaling->propertyFlags,
                   sizeof(VkMemoryPropertyFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->heapIndex, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceFeatures(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkPhysicalDeviceFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->imageCubeArray, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->independentBlend, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->geometryShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->tessellationShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sampleRateShading, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->dualSrcBlend, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->logicOp, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiDrawIndirect, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->depthClamp, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->depthBiasClamp, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fillModeNonSolid, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->depthBounds, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->wideLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->largePoints, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->alphaToOne, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiViewport, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->samplerAnisotropy, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureCompressionETC2, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureCompressionBC, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->occlusionQueryPrecise, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderImageGatherExtended, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageReadWithoutFormat,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderClipDistance, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderCullDistance, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInt64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInt16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderResourceResidency, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderResourceMinLod, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseBinding, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyBuffer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage2D, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage3D, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidency2Samples, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidency4Samples, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidency8Samples, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidency16Samples, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyAliased, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->variableMultisampleRate, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->inheritedQueries, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFeatures(VulkanStream* vkStream, VkStructureType rootType,
                                        VkPhysicalDeviceFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fullDrawIndexUint32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->imageCubeArray, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->independentBlend, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->geometryShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->tessellationShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sampleRateShading, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->dualSrcBlend, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->logicOp, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiDrawIndirect, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->depthClamp, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->depthBiasClamp, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fillModeNonSolid, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->depthBounds, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->wideLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->largePoints, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->alphaToOne, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiViewport, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->samplerAnisotropy, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionETC2, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionBC, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryPrecise, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTessellationAndGeometryPointSize,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageGatherExtended, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageExtendedFormats,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageReadWithoutFormat,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageWriteWithoutFormat,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderClipDistance, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderCullDistance, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceResidency, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceMinLod, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseBinding, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyBuffer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage2D, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage3D, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency2Samples, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency4Samples, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency8Samples, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency16Samples, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyAliased, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->variableMultisampleRate, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->inheritedQueries, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceLimits(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkPhysicalDeviceLimits* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension1D, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension2D, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension3D, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageDimensionCube, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTexelBufferElements, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxUniformBufferRange, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStorageBufferRange, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPushConstantsSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUniformBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSampledImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageResources, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributes, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindings, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVertexOutputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationPatchSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxGeometryInputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentInputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentCombinedOutputResources,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->subPixelPrecisionBits, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->subTexelPrecisionBits, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->mipmapPrecisionBits, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDrawIndirectCount, sizeof(uint32_t));
    vkStream->write((float*)&forMarshaling->maxSamplerLodBias, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxSamplerAnisotropy, sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->maxViewports, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
    vkStream->write((float*)forMarshaling->viewportBoundsRange, 2 * sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->viewportSubPixelBits, sizeof(uint32_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->minMemoryMapAlignment;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((int32_t*)&forMarshaling->minTexelOffset, sizeof(int32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTexelOffset, sizeof(uint32_t));
    vkStream->write((int32_t*)&forMarshaling->minTexelGatherOffset, sizeof(int32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTexelGatherOffset, sizeof(uint32_t));
    vkStream->write((float*)&forMarshaling->minInterpolationOffset, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxInterpolationOffset, sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferWidth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferHeight, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferLayers, sizeof(uint32_t));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((uint32_t*)&forMarshaling->maxColorAttachments, sizeof(uint32_t));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts,
                    sizeof(VkSampleCountFlags));
    vkStream->write((uint32_t*)&forMarshaling->maxSampleMaskWords, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
    vkStream->write((float*)&forMarshaling->timestampPeriod, sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->maxClipDistances, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxCullDistances, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->discreteQueuePriorities, sizeof(uint32_t));
    vkStream->write((float*)forMarshaling->pointSizeRange, 2 * sizeof(float));
    vkStream->write((float*)forMarshaling->lineWidthRange, 2 * sizeof(float));
    vkStream->write((float*)&forMarshaling->pointSizeGranularity, sizeof(float));
    vkStream->write((float*)&forMarshaling->lineWidthGranularity, sizeof(float));
    vkStream->write((VkBool32*)&forMarshaling->strictLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->standardSampleLocations, sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceLimits(VulkanStream* vkStream, VkStructureType rootType,
                                      VkPhysicalDeviceLimits* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension1D, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension2D, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension3D, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimensionCube, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelBufferElements, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxUniformBufferRange, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStorageBufferRange, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPushConstantsSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUniformBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSampledImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInputAttachments,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageResources, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffersDynamic,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffersDynamic,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributes, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindings, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexOutputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationPatchSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexInputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexOutputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerPatchOutputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlTotalOutputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationInputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationOutputComponents,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryInputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentInputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentCombinedOutputResources,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->subPixelPrecisionBits, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->subTexelPrecisionBits, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->mipmapPrecisionBits, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndirectCount, sizeof(uint32_t));
    vkStream->read((float*)&forUnmarshaling->maxSamplerLodBias, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxSamplerAnisotropy, sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->maxViewports, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
    vkStream->read((float*)forUnmarshaling->viewportBoundsRange, 2 * sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportSubPixelBits, sizeof(uint32_t));
    forUnmarshaling->minMemoryMapAlignment = (size_t)vkStream->getBe64();
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minTexelBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minUniformBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minStorageBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((int32_t*)&forUnmarshaling->minTexelOffset, sizeof(int32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelOffset, sizeof(uint32_t));
    vkStream->read((int32_t*)&forUnmarshaling->minTexelGatherOffset, sizeof(int32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelGatherOffset, sizeof(uint32_t));
    vkStream->read((float*)&forUnmarshaling->minInterpolationOffset, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxInterpolationOffset, sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferWidth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferHeight, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferLayers, sizeof(uint32_t));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferColorSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferDepthSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferStencilSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferNoAttachmentsSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->maxColorAttachments, sizeof(uint32_t));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageColorSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageIntegerSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageDepthSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageStencilSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->storageImageSampleCounts,
                   sizeof(VkSampleCountFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSampleMaskWords, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
    vkStream->read((float*)&forUnmarshaling->timestampPeriod, sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->maxClipDistances, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxCullDistances, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->discreteQueuePriorities, sizeof(uint32_t));
    vkStream->read((float*)forUnmarshaling->pointSizeRange, 2 * sizeof(float));
    vkStream->read((float*)forUnmarshaling->lineWidthRange, 2 * sizeof(float));
    vkStream->read((float*)&forUnmarshaling->pointSizeGranularity, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->lineWidthGranularity, sizeof(float));
    vkStream->read((VkBool32*)&forUnmarshaling->strictLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->standardSampleLocations, sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyRowPitchAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
}

void marshal_VkPhysicalDeviceMemoryProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeCount, sizeof(uint32_t));
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
        marshal_VkMemoryType(vkStream, rootType, (VkMemoryType*)(forMarshaling->memoryTypes + i));
    }
    vkStream->write((uint32_t*)&forMarshaling->memoryHeapCount, sizeof(uint32_t));
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
        marshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i));
    }
}

void unmarshal_VkPhysicalDeviceMemoryProperties(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceMemoryProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeCount, sizeof(uint32_t));
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
        unmarshal_VkMemoryType(vkStream, rootType,
                               (VkMemoryType*)(forUnmarshaling->memoryTypes + i));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryHeapCount, sizeof(uint32_t));
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
        unmarshal_VkMemoryHeap(vkStream, rootType,
                               (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
    }
}

void marshal_VkPhysicalDeviceSparseProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSparseProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->residencyAlignedMipSize, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->residencyNonResidentStrict, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSparseProperties(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceSparseProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DMultisampleBlockShape,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->residencyAlignedMipSize, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->residencyNonResidentStrict, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceProperties(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkPhysicalDeviceProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
    vkStream->write((VkPhysicalDeviceType*)&forMarshaling->deviceType,
                    sizeof(VkPhysicalDeviceType));
    vkStream->write((char*)forMarshaling->deviceName,
                    VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
    vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    marshal_VkPhysicalDeviceLimits(vkStream, rootType,
                                   (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
    marshal_VkPhysicalDeviceSparseProperties(
        vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties));
}

void unmarshal_VkPhysicalDeviceProperties(VulkanStream* vkStream, VkStructureType rootType,
                                          VkPhysicalDeviceProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
    vkStream->read((VkPhysicalDeviceType*)&forUnmarshaling->deviceType,
                   sizeof(VkPhysicalDeviceType));
    vkStream->read((char*)forUnmarshaling->deviceName,
                   VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
    vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    unmarshal_VkPhysicalDeviceLimits(vkStream, rootType,
                                     (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
    unmarshal_VkPhysicalDeviceSparseProperties(
        vkStream, rootType,
        (VkPhysicalDeviceSparseProperties*)(&forUnmarshaling->sparseProperties));
}

void marshal_VkQueueFamilyProperties(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkQueueFamilyProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
    vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
    marshal_VkExtent3D(vkStream, rootType,
                       (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
}

void unmarshal_VkQueueFamilyProperties(VulkanStream* vkStream, VkStructureType rootType,
                                       VkQueueFamilyProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkQueueFlags*)&forUnmarshaling->queueFlags, sizeof(VkQueueFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->timestampValidBits, sizeof(uint32_t));
    unmarshal_VkExtent3D(vkStream, rootType,
                         (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
}

void marshal_VkDeviceQueueCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkDeviceQueueCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags,
                    sizeof(VkDeviceQueueCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
    vkStream->write((const float*)forMarshaling->pQueuePriorities,
                    forMarshaling->queueCount * sizeof(const float));
}

void unmarshal_VkDeviceQueueCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       VkDeviceQueueCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkDeviceQueueCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pQueuePriorities,
                    forUnmarshaling->queueCount * sizeof(const float));
    vkStream->read((float*)forUnmarshaling->pQueuePriorities,
                   forUnmarshaling->queueCount * sizeof(const float));
}

void marshal_VkDeviceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                const VkDeviceCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i) {
            marshal_VkDeviceQueueCreateInfo(
                vkStream, rootType,
                (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
    saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
    vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
    saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames,
                    forMarshaling->enabledExtensionCount);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pEnabledFeatures) {
        marshal_VkPhysicalDeviceFeatures(
            vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
    }
}

void unmarshal_VkDeviceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  VkDeviceCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->queueCreateInfoCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pQueueCreateInfos,
                    forUnmarshaling->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i) {
            unmarshal_VkDeviceQueueCreateInfo(
                vkStream, rootType,
                (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
    vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
    // WARNING PTR CHECK
    forUnmarshaling->pEnabledFeatures =
        (const VkPhysicalDeviceFeatures*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pEnabledFeatures) {
        vkStream->alloc((void**)&forUnmarshaling->pEnabledFeatures,
                        sizeof(const VkPhysicalDeviceFeatures));
        unmarshal_VkPhysicalDeviceFeatures(
            vkStream, rootType, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
    }
}

void marshal_VkExtensionProperties(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkExtensionProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
}

void unmarshal_VkExtensionProperties(VulkanStream* vkStream, VkStructureType rootType,
                                     VkExtensionProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((char*)forUnmarshaling->extensionName,
                   VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
}

void marshal_VkLayerProperties(VulkanStream* vkStream, VkStructureType rootType,
                               const VkLayerProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->implementationVersion, sizeof(uint32_t));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void unmarshal_VkLayerProperties(VulkanStream* vkStream, VkStructureType rootType,
                                 VkLayerProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((char*)forUnmarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->implementationVersion, sizeof(uint32_t));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void marshal_VkSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                          const VkSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    if (forMarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
    }
    vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask,
                    forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
    if (forMarshaling->commandBufferCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->commandBufferCount * 8);
        vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(
            forMarshaling->pCommandBuffers, cgen_var_1, forMarshaling->commandBufferCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->commandBufferCount * 8);
    }
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    if (forMarshaling->signalSemaphoreCount) {
        uint64_t* cgen_var_2;
        vkStream->alloc((void**)&cgen_var_2, forMarshaling->signalSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pSignalSemaphores, cgen_var_2, forMarshaling->signalSemaphoreCount);
        vkStream->write((uint64_t*)cgen_var_2, forMarshaling->signalSemaphoreCount * 8);
    }
}

void unmarshal_VkSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                            VkSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores,
                    forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
            forUnmarshaling->waitSemaphoreCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pWaitDstStageMask,
                    forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
    vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask,
                   forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCommandBuffers,
                    forUnmarshaling->commandBufferCount * sizeof(const VkCommandBuffer));
    if (forUnmarshaling->commandBufferCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->commandBufferCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->commandBufferCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
            cgen_var_1, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers,
            forUnmarshaling->commandBufferCount);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores,
                    forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->signalSemaphoreCount) {
        uint64_t* cgen_var_2;
        vkStream->alloc((void**)&cgen_var_2, forUnmarshaling->signalSemaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_2, forUnmarshaling->signalSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_2, (VkSemaphore*)forUnmarshaling->pSignalSemaphores,
            forUnmarshaling->signalSemaphoreCount);
    }
}

void marshal_VkMappedMemoryRange(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkMappedMemoryRange* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkMappedMemoryRange(VulkanStream* vkStream, VkStructureType rootType,
                                   VkMappedMemoryRange* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkMemoryAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkMemoryAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
}

void unmarshal_VkMemoryAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    VkMemoryAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
}

void marshal_VkMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkMemoryRequirements* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                    VkMemoryRequirements* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->alignment, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkSparseMemoryBind(VulkanStream* vkStream, VkStructureType rootType,
                                const VkSparseMemoryBind* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags,
                    sizeof(VkSparseMemoryBindFlags));
}

void unmarshal_VkSparseMemoryBind(VulkanStream* vkStream, VkStructureType rootType,
                                  VkSparseMemoryBind* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags,
                   sizeof(VkSparseMemoryBindFlags));
}

void marshal_VkSparseBufferMemoryBindInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkSparseBufferMemoryBindInfo* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
            marshal_VkSparseMemoryBind(vkStream, rootType,
                                       (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
        }
    }
}

void unmarshal_VkSparseBufferMemoryBindInfo(VulkanStream* vkStream, VkStructureType rootType,
                                            VkSparseBufferMemoryBindInfo* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pBinds,
                    forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
            unmarshal_VkSparseMemoryBind(vkStream, rootType,
                                         (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
        }
    }
}

void marshal_VkSparseImageOpaqueMemoryBindInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSparseImageOpaqueMemoryBindInfo* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
            marshal_VkSparseMemoryBind(vkStream, rootType,
                                       (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
        }
    }
}

void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pBinds,
                    forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
            unmarshal_VkSparseMemoryBind(vkStream, rootType,
                                         (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
        }
    }
}

void marshal_VkImageSubresource(VulkanStream* vkStream, VkStructureType rootType,
                                const VkImageSubresource* forMarshaling) {
    (void)rootType;
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->arrayLayer, sizeof(uint32_t));
}

void unmarshal_VkImageSubresource(VulkanStream* vkStream, VkStructureType rootType,
                                  VkImageSubresource* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->arrayLayer, sizeof(uint32_t));
}

void marshal_VkSparseImageMemoryBind(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkSparseImageMemoryBind* forMarshaling) {
    (void)rootType;
    marshal_VkImageSubresource(vkStream, rootType,
                               (VkImageSubresource*)(&forMarshaling->subresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->offset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags,
                    sizeof(VkSparseMemoryBindFlags));
}

void unmarshal_VkSparseImageMemoryBind(VulkanStream* vkStream, VkStructureType rootType,
                                       VkSparseImageMemoryBind* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkImageSubresource(vkStream, rootType,
                                 (VkImageSubresource*)(&forUnmarshaling->subresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->offset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags,
                   sizeof(VkSparseMemoryBindFlags));
}

void marshal_VkSparseImageMemoryBindInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkSparseImageMemoryBindInfo* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
            marshal_VkSparseImageMemoryBind(
                vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
        }
    }
}

void unmarshal_VkSparseImageMemoryBindInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkSparseImageMemoryBindInfo* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pBinds,
                    forUnmarshaling->bindCount * sizeof(const VkSparseImageMemoryBind));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
            unmarshal_VkSparseImageMemoryBind(
                vkStream, rootType, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
        }
    }
}

void marshal_VkBindSparseInfo(VulkanStream* vkStream, VkStructureType rootType,
                              const VkBindSparseInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    if (forMarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
    }
    vkStream->write((uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i) {
            marshal_VkSparseBufferMemoryBindInfo(
                vkStream, rootType,
                (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i) {
            marshal_VkSparseImageOpaqueMemoryBindInfo(
                vkStream, rootType,
                (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i) {
            marshal_VkSparseImageMemoryBindInfo(
                vkStream, rootType,
                (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    if (forMarshaling->signalSemaphoreCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->signalSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pSignalSemaphores, cgen_var_1, forMarshaling->signalSemaphoreCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->signalSemaphoreCount * 8);
    }
}

void unmarshal_VkBindSparseInfo(VulkanStream* vkStream, VkStructureType rootType,
                                VkBindSparseInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores,
                    forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
            forUnmarshaling->waitSemaphoreCount);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->bufferBindCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pBufferBinds,
                    forUnmarshaling->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i) {
            unmarshal_VkSparseBufferMemoryBindInfo(
                vkStream, rootType,
                (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->imageOpaqueBindCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pImageOpaqueBinds,
        forUnmarshaling->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i) {
            unmarshal_VkSparseImageOpaqueMemoryBindInfo(
                vkStream, rootType,
                (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->imageBindCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pImageBinds,
                    forUnmarshaling->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i) {
            unmarshal_VkSparseImageMemoryBindInfo(
                vkStream, rootType,
                (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores,
                    forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->signalSemaphoreCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->signalSemaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->signalSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_1, (VkSemaphore*)forUnmarshaling->pSignalSemaphores,
            forUnmarshaling->signalSemaphoreCount);
    }
}

void marshal_VkSparseImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkSparseImageFormatProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity));
    vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags,
                    sizeof(VkSparseImageFormatFlags));
}

void unmarshal_VkSparseImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                             VkSparseImageFormatProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
    vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags,
                   sizeof(VkSparseImageFormatFlags));
}

void marshal_VkSparseImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkSparseImageMemoryRequirements* forMarshaling) {
    (void)rootType;
    marshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
    vkStream->write((uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailStride, sizeof(VkDeviceSize));
}

void unmarshal_VkSparseImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                               VkSparseImageMemoryRequirements* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
    vkStream->read((uint32_t*)&forUnmarshaling->imageMipTailFirstLod, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailSize, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailStride, sizeof(VkDeviceSize));
}

void marshal_VkFenceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                               const VkFenceCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
}

void unmarshal_VkFenceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 VkFenceCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFenceCreateFlags*)&forUnmarshaling->flags, sizeof(VkFenceCreateFlags));
}

void marshal_VkSemaphoreCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkSemaphoreCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
}

void unmarshal_VkSemaphoreCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkSemaphoreCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkSemaphoreCreateFlags));
}

void marshal_VkEventCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                               const VkEventCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
}

void unmarshal_VkEventCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 VkEventCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkEventCreateFlags*)&forUnmarshaling->flags, sizeof(VkEventCreateFlags));
}

void marshal_VkQueryPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkQueryPoolCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
    vkStream->write((VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
    vkStream->write((uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
    vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
                    sizeof(VkQueryPipelineStatisticFlags));
}

void unmarshal_VkQueryPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkQueryPoolCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkQueryPoolCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkQueryPoolCreateFlags));
    vkStream->read((VkQueryType*)&forUnmarshaling->queryType, sizeof(VkQueryType));
    vkStream->read((uint32_t*)&forUnmarshaling->queryCount, sizeof(uint32_t));
    vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics,
                   sizeof(VkQueryPipelineStatisticFlags));
}

void marshal_VkBufferCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                const VkBufferCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
    vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pQueueFamilyIndices) {
        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
                        forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void unmarshal_VkBufferCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  VkBufferCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
    vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pQueueFamilyIndices) {
        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices,
                        forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
                       forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void marshal_VkBufferViewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkBufferViewCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags,
                    sizeof(VkBufferViewCreateFlags));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}

void unmarshal_VkBufferViewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      VkBufferViewCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkBufferViewCreateFlags));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}

void marshal_VkImageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                               const VkImageCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
    vkStream->write((VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
    vkStream->write((uint32_t*)&forMarshaling->mipLevels, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->arrayLayers, sizeof(uint32_t));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pQueueFamilyIndices) {
        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
                        forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
}

void unmarshal_VkImageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 VkImageCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
    vkStream->read((VkImageType*)&forUnmarshaling->imageType, sizeof(VkImageType));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
    vkStream->read((uint32_t*)&forUnmarshaling->mipLevels, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->arrayLayers, sizeof(uint32_t));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pQueueFamilyIndices) {
        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices,
                        forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
                       forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
}

void marshal_VkSubresourceLayout(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSubresourceLayout* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->rowPitch, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->arrayPitch, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->depthPitch, sizeof(VkDeviceSize));
}

void unmarshal_VkSubresourceLayout(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSubresourceLayout* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->rowPitch, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->arrayPitch, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->depthPitch, sizeof(VkDeviceSize));
}

void marshal_VkComponentMapping(VulkanStream* vkStream, VkStructureType rootType,
                                const VkComponentMapping* forMarshaling) {
    (void)rootType;
    vkStream->write((VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
    vkStream->write((VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
    vkStream->write((VkComponentSwizzle*)&forMarshaling->b, sizeof(VkComponentSwizzle));
    vkStream->write((VkComponentSwizzle*)&forMarshaling->a, sizeof(VkComponentSwizzle));
}

void unmarshal_VkComponentMapping(VulkanStream* vkStream, VkStructureType rootType,
                                  VkComponentMapping* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->r, sizeof(VkComponentSwizzle));
    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->g, sizeof(VkComponentSwizzle));
    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->b, sizeof(VkComponentSwizzle));
    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->a, sizeof(VkComponentSwizzle));
}

void marshal_VkImageViewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkImageViewCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    marshal_VkComponentMapping(vkStream, rootType,
                               (VkComponentMapping*)(&forMarshaling->components));
    marshal_VkImageSubresourceRange(vkStream, rootType,
                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}

void unmarshal_VkImageViewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkImageViewCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkImageViewCreateFlags));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    vkStream->read((VkImageViewType*)&forUnmarshaling->viewType, sizeof(VkImageViewType));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    unmarshal_VkComponentMapping(vkStream, rootType,
                                 (VkComponentMapping*)(&forUnmarshaling->components));
    unmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}

void marshal_VkShaderModuleCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkShaderModuleCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags,
                    sizeof(VkShaderModuleCreateFlags));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const uint32_t*)forMarshaling->pCode,
                    (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
}

void unmarshal_VkShaderModuleCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        VkShaderModuleCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkShaderModuleCreateFlags));
    forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pCode,
                    (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pCode,
                   (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
}

void marshal_VkPipelineCacheCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkPipelineCacheCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineCacheCreateFlags));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pInitialData,
                    forMarshaling->initialDataSize * sizeof(const uint8_t));
}

void unmarshal_VkPipelineCacheCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkPipelineCacheCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineCacheCreateFlags));
    forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pInitialData,
                    forUnmarshaling->initialDataSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pInitialData,
                   forUnmarshaling->initialDataSize * sizeof(const uint8_t));
}

void marshal_VkSpecializationMapEntry(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkSpecializationMapEntry* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->size;
    vkStream->putBe64(cgen_var_0);
}

void unmarshal_VkSpecializationMapEntry(VulkanStream* vkStream, VkStructureType rootType,
                                        VkSpecializationMapEntry* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->constantID, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
    forUnmarshaling->size = (size_t)vkStream->getBe64();
}

void marshal_VkSpecializationInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkSpecializationInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i) {
            marshal_VkSpecializationMapEntry(
                vkStream, rootType,
                (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
        }
    }
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pData,
                    forMarshaling->dataSize * sizeof(const uint8_t));
}

void unmarshal_VkSpecializationInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    VkSpecializationInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->mapEntryCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pMapEntries,
                    forUnmarshaling->mapEntryCount * sizeof(const VkSpecializationMapEntry));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mapEntryCount; ++i) {
            unmarshal_VkSpecializationMapEntry(
                vkStream, rootType, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
        }
    }
    forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pData,
                    forUnmarshaling->dataSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pData,
                   forUnmarshaling->dataSize * sizeof(const uint8_t));
}

void marshal_VkPipelineShaderStageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPipelineShaderStageCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineShaderStageCreateFlags));
    vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->putString(forMarshaling->pName);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pSpecializationInfo) {
        marshal_VkSpecializationInfo(
            vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
    }
}

void unmarshal_VkPipelineShaderStageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                               VkPipelineShaderStageCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineShaderStageCreateFlags));
    vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkShaderModule(
        &cgen_var_0, (VkShaderModule*)&forUnmarshaling->module, 1);
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
    // WARNING PTR CHECK
    forUnmarshaling->pSpecializationInfo =
        (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSpecializationInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo,
                        sizeof(const VkSpecializationInfo));
        unmarshal_VkSpecializationInfo(
            vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
    }
}

void marshal_VkComputePipelineCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkComputePipelineCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    marshal_VkPipelineShaderStageCreateInfo(
        vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
                                                               1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
                                                         &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}

void unmarshal_VkComputePipelineCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkComputePipelineCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
    unmarshal_VkPipelineShaderStageCreateInfo(
        vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}

void marshal_VkVertexInputBindingDescription(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVertexInputBindingDescription* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
    vkStream->write((VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
}

void unmarshal_VkVertexInputBindingDescription(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVertexInputBindingDescription* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
    vkStream->read((VkVertexInputRate*)&forUnmarshaling->inputRate, sizeof(VkVertexInputRate));
}

void marshal_VkVertexInputAttributeDescription(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVertexInputAttributeDescription* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->location, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
}

void unmarshal_VkVertexInputAttributeDescription(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVertexInputAttributeDescription* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->location, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
}

void marshal_VkPipelineVertexInputStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineVertexInputStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineVertexInputStateCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i) {
            marshal_VkVertexInputBindingDescription(
                vkStream, rootType,
                (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions +
                                                         i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i) {
            marshal_VkVertexInputAttributeDescription(
                vkStream, rootType,
                (const VkVertexInputAttributeDescription*)(forMarshaling
                                                               ->pVertexAttributeDescriptions +
                                                           i));
        }
    }
}

void unmarshal_VkPipelineVertexInputStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineVertexInputStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineVertexInputStateCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDescriptions,
                    forUnmarshaling->vertexBindingDescriptionCount *
                        sizeof(const VkVertexInputBindingDescription));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i) {
            unmarshal_VkVertexInputBindingDescription(
                vkStream, rootType,
                (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions +
                                                   i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pVertexAttributeDescriptions,
                    forUnmarshaling->vertexAttributeDescriptionCount *
                        sizeof(const VkVertexInputAttributeDescription));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i) {
            unmarshal_VkVertexInputAttributeDescription(
                vkStream, rootType,
                (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions +
                                                     i));
        }
    }
}

void marshal_VkPipelineInputAssemblyStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineInputAssemblyStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineInputAssemblyStateCreateFlags));
    vkStream->write((VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
    vkStream->write((VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
}

void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineInputAssemblyStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineInputAssemblyStateCreateFlags));
    vkStream->read((VkPrimitiveTopology*)&forUnmarshaling->topology, sizeof(VkPrimitiveTopology));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveRestartEnable, sizeof(VkBool32));
}

void marshal_VkPipelineTessellationStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineTessellationStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineTessellationStateCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
}

void unmarshal_VkPipelineTessellationStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineTessellationStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineTessellationStateCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
}

void marshal_VkViewport(VulkanStream* vkStream, VkStructureType rootType,
                        const VkViewport* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->x, sizeof(float));
    vkStream->write((float*)&forMarshaling->y, sizeof(float));
    vkStream->write((float*)&forMarshaling->width, sizeof(float));
    vkStream->write((float*)&forMarshaling->height, sizeof(float));
    vkStream->write((float*)&forMarshaling->minDepth, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxDepth, sizeof(float));
}

void unmarshal_VkViewport(VulkanStream* vkStream, VkStructureType rootType,
                          VkViewport* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->width, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->height, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->minDepth, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxDepth, sizeof(float));
}

void marshal_VkPipelineViewportStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineViewportStateCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pViewports) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
                marshal_VkViewport(vkStream, rootType,
                                   (const VkViewport*)(forMarshaling->pViewports + i));
            }
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pScissors) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i) {
                marshal_VkRect2D(vkStream, rootType,
                                 (const VkRect2D*)(forMarshaling->pScissors + i));
            }
        }
    }
}

void unmarshal_VkPipelineViewportStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineViewportStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineViewportStateCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pViewports = (const VkViewport*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pViewports) {
        vkStream->alloc((void**)&forUnmarshaling->pViewports,
                        forUnmarshaling->viewportCount * sizeof(const VkViewport));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
                unmarshal_VkViewport(vkStream, rootType,
                                     (VkViewport*)(forUnmarshaling->pViewports + i));
            }
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->scissorCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pScissors) {
        vkStream->alloc((void**)&forUnmarshaling->pScissors,
                        forUnmarshaling->scissorCount * sizeof(const VkRect2D));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i) {
                unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pScissors + i));
            }
        }
    }
}

void marshal_VkPipelineRasterizationStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineRasterizationStateCreateFlags));
    vkStream->write((VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
    vkStream->write((VkPolygonMode*)&forMarshaling->polygonMode, sizeof(VkPolygonMode));
    vkStream->write((VkCullModeFlags*)&forMarshaling->cullMode, sizeof(VkCullModeFlags));
    vkStream->write((VkFrontFace*)&forMarshaling->frontFace, sizeof(VkFrontFace));
    vkStream->write((VkBool32*)&forMarshaling->depthBiasEnable, sizeof(VkBool32));
    vkStream->write((float*)&forMarshaling->depthBiasConstantFactor, sizeof(float));
    vkStream->write((float*)&forMarshaling->depthBiasClamp, sizeof(float));
    vkStream->write((float*)&forMarshaling->depthBiasSlopeFactor, sizeof(float));
    vkStream->write((float*)&forMarshaling->lineWidth, sizeof(float));
}

void unmarshal_VkPipelineRasterizationStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineRasterizationStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineRasterizationStateCreateFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->depthClampEnable, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
    vkStream->read((VkPolygonMode*)&forUnmarshaling->polygonMode, sizeof(VkPolygonMode));
    vkStream->read((VkCullModeFlags*)&forUnmarshaling->cullMode, sizeof(VkCullModeFlags));
    vkStream->read((VkFrontFace*)&forUnmarshaling->frontFace, sizeof(VkFrontFace));
    vkStream->read((VkBool32*)&forUnmarshaling->depthBiasEnable, sizeof(VkBool32));
    vkStream->read((float*)&forUnmarshaling->depthBiasConstantFactor, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->depthBiasClamp, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->depthBiasSlopeFactor, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->lineWidth, sizeof(float));
}

void marshal_VkPipelineMultisampleStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineMultisampleStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineMultisampleStateCreateFlags));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
                    sizeof(VkSampleCountFlagBits));
    vkStream->write((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
    vkStream->write((float*)&forMarshaling->minSampleShading, sizeof(float));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pSampleMask) {
        vkStream->write(
            (const VkSampleMask*)forMarshaling->pSampleMask,
            (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
    }
    vkStream->write((VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->alphaToOneEnable, sizeof(VkBool32));
}

void unmarshal_VkPipelineMultisampleStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineMultisampleStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineMultisampleStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineMultisampleStateCreateFlags));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkBool32*)&forUnmarshaling->sampleShadingEnable, sizeof(VkBool32));
    vkStream->read((float*)&forUnmarshaling->minSampleShading, sizeof(float));
    // WARNING PTR CHECK
    forUnmarshaling->pSampleMask = (const VkSampleMask*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSampleMask) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pSampleMask,
            (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
        vkStream->read(
            (VkSampleMask*)forUnmarshaling->pSampleMask,
            (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->alphaToCoverageEnable, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->alphaToOneEnable, sizeof(VkBool32));
}

void marshal_VkStencilOpState(VulkanStream* vkStream, VkStructureType rootType,
                              const VkStencilOpState* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
    vkStream->write((VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
    vkStream->write((VkStencilOp*)&forMarshaling->depthFailOp, sizeof(VkStencilOp));
    vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
    vkStream->write((uint32_t*)&forMarshaling->compareMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->writeMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->reference, sizeof(uint32_t));
}

void unmarshal_VkStencilOpState(VulkanStream* vkStream, VkStructureType rootType,
                                VkStencilOpState* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStencilOp*)&forUnmarshaling->failOp, sizeof(VkStencilOp));
    vkStream->read((VkStencilOp*)&forUnmarshaling->passOp, sizeof(VkStencilOp));
    vkStream->read((VkStencilOp*)&forUnmarshaling->depthFailOp, sizeof(VkStencilOp));
    vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
    vkStream->read((uint32_t*)&forUnmarshaling->compareMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->writeMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->reference, sizeof(uint32_t));
}

void marshal_VkPipelineDepthStencilStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineDepthStencilStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineDepthStencilStateCreateFlags));
    vkStream->write((VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->depthWriteEnable, sizeof(VkBool32));
    vkStream->write((VkCompareOp*)&forMarshaling->depthCompareOp, sizeof(VkCompareOp));
    vkStream->write((VkBool32*)&forMarshaling->depthBoundsTestEnable, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
    marshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->front));
    marshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->back));
    vkStream->write((float*)&forMarshaling->minDepthBounds, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxDepthBounds, sizeof(float));
}

void unmarshal_VkPipelineDepthStencilStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineDepthStencilStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineDepthStencilStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineDepthStencilStateCreateFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->depthTestEnable, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->depthWriteEnable, sizeof(VkBool32));
    vkStream->read((VkCompareOp*)&forUnmarshaling->depthCompareOp, sizeof(VkCompareOp));
    vkStream->read((VkBool32*)&forUnmarshaling->depthBoundsTestEnable, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->stencilTestEnable, sizeof(VkBool32));
    unmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forUnmarshaling->front));
    unmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forUnmarshaling->back));
    vkStream->read((float*)&forUnmarshaling->minDepthBounds, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxDepthBounds, sizeof(float));
}

void marshal_VkPipelineColorBlendAttachmentState(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineColorBlendAttachmentState* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
    vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
    vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
    vkStream->write((VkColorComponentFlags*)&forMarshaling->colorWriteMask,
                    sizeof(VkColorComponentFlags));
}

void unmarshal_VkPipelineColorBlendAttachmentState(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineColorBlendAttachmentState* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBool32*)&forUnmarshaling->blendEnable, sizeof(VkBool32));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendOp*)&forUnmarshaling->colorBlendOp, sizeof(VkBlendOp));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
    vkStream->read((VkColorComponentFlags*)&forUnmarshaling->colorWriteMask,
                   sizeof(VkColorComponentFlags));
}

void marshal_VkPipelineColorBlendStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineColorBlendStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineColorBlendStateCreateFlags));
    vkStream->write((VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
    vkStream->write((VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
            marshal_VkPipelineColorBlendAttachmentState(
                vkStream, rootType,
                (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
        }
    }
    vkStream->write((float*)forMarshaling->blendConstants, 4 * sizeof(float));
}

void unmarshal_VkPipelineColorBlendStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineColorBlendStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineColorBlendStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineColorBlendStateCreateFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->logicOpEnable, sizeof(VkBool32));
    vkStream->read((VkLogicOp*)&forUnmarshaling->logicOp, sizeof(VkLogicOp));
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pAttachments,
        forUnmarshaling->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
            unmarshal_VkPipelineColorBlendAttachmentState(
                vkStream, rootType,
                (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
        }
    }
    vkStream->read((float*)forUnmarshaling->blendConstants, 4 * sizeof(float));
}

void marshal_VkPipelineDynamicStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineDynamicStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineDynamicStateCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
    vkStream->write((const VkDynamicState*)forMarshaling->pDynamicStates,
                    forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
}

void unmarshal_VkPipelineDynamicStateCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPipelineDynamicStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineDynamicStateCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDynamicStates,
                    forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
    vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates,
                   forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
}

void marshal_VkGraphicsPipelineCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkGraphicsPipelineCreateInfo* forMarshaling) {
    (void)rootType;
    uint32_t hasRasterization = 1;
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        hasRasterization =
            (((0 == forMarshaling->pRasterizationState))
                 ? (0)
                 : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
        uint32_t cgen_var_0 = (uint32_t)hasRasterization;
        vkStream->putBe32(cgen_var_0);
    }
    uint32_t hasTessellation = 1;
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        hasTessellation =
            arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount,
                     [](VkPipelineShaderStageCreateInfo s) {
                         return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
                                 (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
                     });
        uint32_t cgen_var_0 = (uint32_t)hasTessellation;
        vkStream->putBe32(cgen_var_0);
    }
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
            marshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
        }
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
        vkStream->putBe64(cgen_var_0);
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pVertexInputState)) {
        marshal_VkPipelineVertexInputStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
        vkStream->putBe64(cgen_var_0);
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pInputAssemblyState)) {
        marshal_VkPipelineInputAssemblyStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pTessellationState) {
        if (hasTessellation) {
            marshal_VkPipelineTessellationStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pViewportState) {
        if (hasRasterization) {
            marshal_VkPipelineViewportStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
        }
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_1_0 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
        vkStream->putBe64(cgen_var_1_0);
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pRasterizationState)) {
        marshal_VkPipelineRasterizationStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pMultisampleState) {
        if (hasRasterization) {
            marshal_VkPipelineMultisampleStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
    vkStream->putBe64(cgen_var_3);
    if (forMarshaling->pDepthStencilState) {
        if (hasRasterization) {
            marshal_VkPipelineDepthStencilStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_4 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
    vkStream->putBe64(cgen_var_4);
    if (forMarshaling->pColorBlendState) {
        if (hasRasterization) {
            marshal_VkPipelineColorBlendStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_5 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
    vkStream->putBe64(cgen_var_5);
    if (forMarshaling->pDynamicState) {
        marshal_VkPipelineDynamicStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
    }
    uint64_t cgen_var_6;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_6,
                                                               1);
    vkStream->write((uint64_t*)&cgen_var_6, 1 * 8);
    uint64_t cgen_var_7;
    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_7,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_7, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    uint64_t cgen_var_8;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
                                                         &cgen_var_8, 1);
    vkStream->write((uint64_t*)&cgen_var_8, 1 * 8);
    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}

void unmarshal_VkGraphicsPipelineCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                            VkGraphicsPipelineCreateInfo* forUnmarshaling) {
    (void)rootType;
    uint32_t hasRasterization = 1;
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        hasRasterization = (const uint32_t)vkStream->getBe32();
    }
    uint32_t hasTessellation = 1;
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        hasTessellation = (const uint32_t)vkStream->getBe32();
    }
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStages,
                    forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
            unmarshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
        }
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        forUnmarshaling->pVertexInputState =
            (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forUnmarshaling->pVertexInputState)) {
        vkStream->alloc((void**)&forUnmarshaling->pVertexInputState,
                        sizeof(const VkPipelineVertexInputStateCreateInfo));
        unmarshal_VkPipelineVertexInputStateCreateInfo(
            vkStream, rootType,
            (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        forUnmarshaling->pInputAssemblyState =
            (const VkPipelineInputAssemblyStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forUnmarshaling->pInputAssemblyState)) {
        vkStream->alloc((void**)&forUnmarshaling->pInputAssemblyState,
                        sizeof(const VkPipelineInputAssemblyStateCreateInfo));
        unmarshal_VkPipelineInputAssemblyStateCreateInfo(
            vkStream, rootType,
            (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pTessellationState =
        (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pTessellationState) {
        if (hasTessellation) {
            vkStream->alloc((void**)&forUnmarshaling->pTessellationState,
                            sizeof(const VkPipelineTessellationStateCreateInfo));
            unmarshal_VkPipelineTessellationStateCreateInfo(
                vkStream, rootType,
                (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
        } else {
            forUnmarshaling->pTessellationState = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pViewportState =
        (const VkPipelineViewportStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pViewportState) {
        if (hasRasterization) {
            vkStream->alloc((void**)&forUnmarshaling->pViewportState,
                            sizeof(const VkPipelineViewportStateCreateInfo));
            unmarshal_VkPipelineViewportStateCreateInfo(
                vkStream, rootType,
                (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
        } else {
            forUnmarshaling->pViewportState = 0;
        }
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        forUnmarshaling->pRasterizationState =
            (const VkPipelineRasterizationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forUnmarshaling->pRasterizationState)) {
        vkStream->alloc((void**)&forUnmarshaling->pRasterizationState,
                        sizeof(const VkPipelineRasterizationStateCreateInfo));
        unmarshal_VkPipelineRasterizationStateCreateInfo(
            vkStream, rootType,
            (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pMultisampleState =
        (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pMultisampleState) {
        if (hasRasterization) {
            vkStream->alloc((void**)&forUnmarshaling->pMultisampleState,
                            sizeof(const VkPipelineMultisampleStateCreateInfo));
            unmarshal_VkPipelineMultisampleStateCreateInfo(
                vkStream, rootType,
                (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
        } else {
            forUnmarshaling->pMultisampleState = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDepthStencilState =
        (const VkPipelineDepthStencilStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDepthStencilState) {
        if (hasRasterization) {
            vkStream->alloc((void**)&forUnmarshaling->pDepthStencilState,
                            sizeof(const VkPipelineDepthStencilStateCreateInfo));
            unmarshal_VkPipelineDepthStencilStateCreateInfo(
                vkStream, rootType,
                (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
        } else {
            forUnmarshaling->pDepthStencilState = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pColorBlendState =
        (const VkPipelineColorBlendStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pColorBlendState) {
        if (hasRasterization) {
            vkStream->alloc((void**)&forUnmarshaling->pColorBlendState,
                            sizeof(const VkPipelineColorBlendStateCreateInfo));
            unmarshal_VkPipelineColorBlendStateCreateInfo(
                vkStream, rootType,
                (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
        } else {
            forUnmarshaling->pColorBlendState = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDynamicState =
        (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDynamicState) {
        vkStream->alloc((void**)&forUnmarshaling->pDynamicState,
                        sizeof(const VkPipelineDynamicStateCreateInfo));
        unmarshal_VkPipelineDynamicStateCreateInfo(
            vkStream, rootType,
            (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
    }
    uint64_t cgen_var_6;
    vkStream->read((uint64_t*)&cgen_var_6, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_6, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
    uint64_t cgen_var_7;
    vkStream->read((uint64_t*)&cgen_var_7, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
        &cgen_var_7, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
    uint64_t cgen_var_8;
    vkStream->read((uint64_t*)&cgen_var_8, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_8, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}

void marshal_VkPushConstantRange(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkPushConstantRange* forMarshaling) {
    (void)rootType;
    vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
}

void unmarshal_VkPushConstantRange(VulkanStream* vkStream, VkStructureType rootType,
                                   VkPushConstantRange* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
}

void marshal_VkPipelineLayoutCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkPipelineLayoutCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineLayoutCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineLayoutCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
    if (forMarshaling->setLayoutCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->setLayoutCount * 8);
        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
            forMarshaling->pSetLayouts, cgen_var_0, forMarshaling->setLayoutCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->setLayoutCount * 8);
    }
    vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
            marshal_VkPushConstantRange(
                vkStream, rootType,
                (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
        }
    }
}

void unmarshal_VkPipelineLayoutCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          VkPipelineLayoutCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineLayoutCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSetLayouts,
                    forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
    if (forUnmarshaling->setLayoutCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->setLayoutCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->setLayoutCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
            cgen_var_0, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
            forUnmarshaling->setLayoutCount);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPushConstantRanges,
                    forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i) {
            unmarshal_VkPushConstantRange(
                vkStream, rootType,
                (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
        }
    }
}

void marshal_VkSamplerCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSamplerCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSamplerCreateFlags*)&forMarshaling->flags, sizeof(VkSamplerCreateFlags));
    vkStream->write((VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
    vkStream->write((VkFilter*)&forMarshaling->minFilter, sizeof(VkFilter));
    vkStream->write((VkSamplerMipmapMode*)&forMarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeU,
                    sizeof(VkSamplerAddressMode));
    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeV,
                    sizeof(VkSamplerAddressMode));
    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeW,
                    sizeof(VkSamplerAddressMode));
    vkStream->write((float*)&forMarshaling->mipLodBias, sizeof(float));
    vkStream->write((VkBool32*)&forMarshaling->anisotropyEnable, sizeof(VkBool32));
    vkStream->write((float*)&forMarshaling->maxAnisotropy, sizeof(float));
    vkStream->write((VkBool32*)&forMarshaling->compareEnable, sizeof(VkBool32));
    vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
    vkStream->write((float*)&forMarshaling->minLod, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxLod, sizeof(float));
    vkStream->write((VkBorderColor*)&forMarshaling->borderColor, sizeof(VkBorderColor));
    vkStream->write((VkBool32*)&forMarshaling->unnormalizedCoordinates, sizeof(VkBool32));
}

void unmarshal_VkSamplerCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSamplerCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSamplerCreateFlags*)&forUnmarshaling->flags, sizeof(VkSamplerCreateFlags));
    vkStream->read((VkFilter*)&forUnmarshaling->magFilter, sizeof(VkFilter));
    vkStream->read((VkFilter*)&forUnmarshaling->minFilter, sizeof(VkFilter));
    vkStream->read((VkSamplerMipmapMode*)&forUnmarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeU,
                   sizeof(VkSamplerAddressMode));
    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeV,
                   sizeof(VkSamplerAddressMode));
    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeW,
                   sizeof(VkSamplerAddressMode));
    vkStream->read((float*)&forUnmarshaling->mipLodBias, sizeof(float));
    vkStream->read((VkBool32*)&forUnmarshaling->anisotropyEnable, sizeof(VkBool32));
    vkStream->read((float*)&forUnmarshaling->maxAnisotropy, sizeof(float));
    vkStream->read((VkBool32*)&forUnmarshaling->compareEnable, sizeof(VkBool32));
    vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
    vkStream->read((float*)&forUnmarshaling->minLod, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxLod, sizeof(float));
    vkStream->read((VkBorderColor*)&forUnmarshaling->borderColor, sizeof(VkBorderColor));
    vkStream->read((VkBool32*)&forUnmarshaling->unnormalizedCoordinates, sizeof(VkBool32));
}

void marshal_VkCopyDescriptorSet(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkCopyDescriptorSet* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_0,
                                                              1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_1,
                                                              1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
}

void unmarshal_VkCopyDescriptorSet(VulkanStream* vkStream, VkStructureType rootType,
                                   VkCopyDescriptorSet* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
        &cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
        &cgen_var_1, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
}

void marshal_VkDescriptorBufferInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkDescriptorBufferInfo* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}

void unmarshal_VkDescriptorBufferInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      VkDescriptorBufferInfo* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}

void marshal_VkDescriptorImageInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkDescriptorImageInfo* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_1,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}

void unmarshal_VkDescriptorImageInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkDescriptorImageInfo* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
                                                        (VkSampler*)&forUnmarshaling->sampler, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_1, (VkImageView*)&forUnmarshaling->imageView, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}

void marshal_VkDescriptorPoolSize(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkDescriptorPoolSize* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
}

void unmarshal_VkDescriptorPoolSize(VulkanStream* vkStream, VkStructureType rootType,
                                    VkDescriptorPoolSize* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
}

void marshal_VkDescriptorPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDescriptorPoolCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDescriptorPoolCreateFlags*)&forMarshaling->flags,
                    sizeof(VkDescriptorPoolCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i) {
            marshal_VkDescriptorPoolSize(
                vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
        }
    }
}

void unmarshal_VkDescriptorPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDescriptorPoolCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDescriptorPoolCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkDescriptorPoolCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSets, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->poolSizeCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPoolSizes,
                    forUnmarshaling->poolSizeCount * sizeof(const VkDescriptorPoolSize));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i) {
            unmarshal_VkDescriptorPoolSize(
                vkStream, rootType, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
        }
    }
}

void marshal_VkDescriptorSetAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDescriptorSetAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool,
                                                               &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
    if (forMarshaling->descriptorSetCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->descriptorSetCount * 8);
        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
            forMarshaling->pSetLayouts, cgen_var_1, forMarshaling->descriptorSetCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->descriptorSetCount * 8);
    }
}

void unmarshal_VkDescriptorSetAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDescriptorSetAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(
        &cgen_var_0, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSetLayouts,
                    forUnmarshaling->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
    if (forUnmarshaling->descriptorSetCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
            cgen_var_1, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
            forUnmarshaling->descriptorSetCount);
    }
}

void marshal_VkDescriptorSetLayoutBinding(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkDescriptorSetLayoutBinding* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pImmutableSamplers) {
        if (forMarshaling->descriptorCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->descriptorCount * 8);
            vkStream->handleMapping()->mapHandles_VkSampler_u64(
                forMarshaling->pImmutableSamplers, cgen_var_0_0, forMarshaling->descriptorCount);
            vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->descriptorCount * 8);
        }
    }
}

void unmarshal_VkDescriptorSetLayoutBinding(VulkanStream* vkStream, VkStructureType rootType,
                                            VkDescriptorSetLayoutBinding* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
    // WARNING PTR CHECK
    forUnmarshaling->pImmutableSamplers = (const VkSampler*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pImmutableSamplers) {
        vkStream->alloc((void**)&forUnmarshaling->pImmutableSamplers,
                        forUnmarshaling->descriptorCount * sizeof(const VkSampler));
        if (forUnmarshaling->descriptorCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->descriptorCount * 8);
            vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->descriptorCount * 8);
            vkStream->handleMapping()->mapHandles_u64_VkSampler(
                cgen_var_0_0, (VkSampler*)forUnmarshaling->pImmutableSamplers,
                forUnmarshaling->descriptorCount);
        }
    }
}

void marshal_VkDescriptorSetLayoutCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkDescriptorSetLayoutCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags,
                    sizeof(VkDescriptorSetLayoutCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i) {
            marshal_VkDescriptorSetLayoutBinding(
                vkStream, rootType,
                (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
        }
    }
}

void unmarshal_VkDescriptorSetLayoutCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                               VkDescriptorSetLayoutCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkDescriptorSetLayoutCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pBindings,
                    forUnmarshaling->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i) {
            unmarshal_VkDescriptorSetLayoutBinding(
                vkStream, rootType,
                (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
        }
    }
}

void marshal_VkWriteDescriptorSet(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkWriteDescriptorSet* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_0,
                                                              1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pImageInfo) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType)))) {
            if (forMarshaling) {
                for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
                    marshal_VkDescriptorImageInfo(
                        vkStream, rootType,
                        (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
                }
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pBufferInfo) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType)))) {
            if (forMarshaling) {
                for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
                    marshal_VkDescriptorBufferInfo(
                        vkStream, rootType,
                        (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
                }
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
    vkStream->putBe64(cgen_var_3);
    if (forMarshaling->pTexelBufferView) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType)))) {
            if (forMarshaling->descriptorCount) {
                uint64_t* cgen_var_3_0;
                vkStream->alloc((void**)&cgen_var_3_0, forMarshaling->descriptorCount * 8);
                vkStream->handleMapping()->mapHandles_VkBufferView_u64(
                    forMarshaling->pTexelBufferView, cgen_var_3_0, forMarshaling->descriptorCount);
                vkStream->write((uint64_t*)cgen_var_3_0, forMarshaling->descriptorCount * 8);
            }
        }
    }
}

void unmarshal_VkWriteDescriptorSet(VulkanStream* vkStream, VkStructureType rootType,
                                    VkWriteDescriptorSet* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
        &cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
    // WARNING PTR CHECK
    forUnmarshaling->pImageInfo = (const VkDescriptorImageInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pImageInfo) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType)))) {
            vkStream->alloc((void**)&forUnmarshaling->pImageInfo,
                            forUnmarshaling->descriptorCount * sizeof(const VkDescriptorImageInfo));
            if (forUnmarshaling) {
                for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i) {
                    unmarshal_VkDescriptorImageInfo(
                        vkStream, rootType,
                        (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
                }
            }
        } else {
            forUnmarshaling->pImageInfo = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pBufferInfo = (const VkDescriptorBufferInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pBufferInfo) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType)))) {
            vkStream->alloc(
                (void**)&forUnmarshaling->pBufferInfo,
                forUnmarshaling->descriptorCount * sizeof(const VkDescriptorBufferInfo));
            if (forUnmarshaling) {
                for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i) {
                    unmarshal_VkDescriptorBufferInfo(
                        vkStream, rootType,
                        (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
                }
            }
        } else {
            forUnmarshaling->pBufferInfo = 0;
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pTexelBufferView = (const VkBufferView*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pTexelBufferView) {
        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
             ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) ||
              (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType)))) {
            vkStream->alloc((void**)&forUnmarshaling->pTexelBufferView,
                            forUnmarshaling->descriptorCount * sizeof(const VkBufferView));
            if (forUnmarshaling->descriptorCount) {
                uint64_t* cgen_var_3_0;
                vkStream->alloc((void**)&cgen_var_3_0, forUnmarshaling->descriptorCount * 8);
                vkStream->read((uint64_t*)cgen_var_3_0, forUnmarshaling->descriptorCount * 8);
                vkStream->handleMapping()->mapHandles_u64_VkBufferView(
                    cgen_var_3_0, (VkBufferView*)forUnmarshaling->pTexelBufferView,
                    forUnmarshaling->descriptorCount);
            }
        } else {
            forUnmarshaling->pTexelBufferView = 0;
        }
    }
}

void marshal_VkAttachmentDescription(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkAttachmentDescription* forMarshaling) {
    (void)rootType;
    vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags,
                    sizeof(VkAttachmentDescriptionFlags));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp,
                    sizeof(VkAttachmentStoreOp));
    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
    vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
}

void unmarshal_VkAttachmentDescription(VulkanStream* vkStream, VkStructureType rootType,
                                       VkAttachmentDescription* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags,
                   sizeof(VkAttachmentDescriptionFlags));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp,
                   sizeof(VkAttachmentLoadOp));
    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp,
                   sizeof(VkAttachmentStoreOp));
    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
    vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
}

void marshal_VkAttachmentReference(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkAttachmentReference* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
    vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
}

void unmarshal_VkAttachmentReference(VulkanStream* vkStream, VkStructureType rootType,
                                     VkAttachmentReference* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
    vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
}

void marshal_VkFramebufferCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkFramebufferCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags,
                    sizeof(VkFramebufferCreateFlags));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         (((forMarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
        if (forMarshaling->attachmentCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->attachmentCount * 8);
            vkStream->handleMapping()->mapHandles_VkImageView_u64(
                forMarshaling->pAttachments, cgen_var_0_0, forMarshaling->attachmentCount);
            vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->attachmentCount * 8);
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->layers, sizeof(uint32_t));
}

void unmarshal_VkFramebufferCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       VkFramebufferCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkFramebufferCreateFlags));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
        &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         (((forUnmarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
        vkStream->alloc((void**)&forUnmarshaling->pAttachments,
                        forUnmarshaling->attachmentCount * sizeof(const VkImageView));
        if (forUnmarshaling->attachmentCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->attachmentCount * 8);
            vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->attachmentCount * 8);
            vkStream->handleMapping()->mapHandles_u64_VkImageView(
                cgen_var_0_0, (VkImageView*)forUnmarshaling->pAttachments,
                forUnmarshaling->attachmentCount);
        }
    } else {
        forUnmarshaling->pAttachments = 0;
    }
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->layers, sizeof(uint32_t));
}

void marshal_VkSubpassDescription(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkSubpassDescription* forMarshaling) {
    (void)rootType;
    vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags,
                    sizeof(VkSubpassDescriptionFlags));
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
            marshal_VkAttachmentReference(
                vkStream, rootType,
                (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
            marshal_VkAttachmentReference(
                vkStream, rootType,
                (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pResolveAttachments) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
                marshal_VkAttachmentReference(
                    vkStream, rootType,
                    (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pDepthStencilAttachment) {
        marshal_VkAttachmentReference(
            vkStream, rootType,
            (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
    }
    vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments,
                    forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}

void unmarshal_VkSubpassDescription(VulkanStream* vkStream, VkStructureType rootType,
                                    VkSubpassDescription* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags,
                   sizeof(VkSubpassDescriptionFlags));
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pInputAttachments,
                    forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i) {
            unmarshal_VkAttachmentReference(
                vkStream, rootType,
                (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pColorAttachments,
                    forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
            unmarshal_VkAttachmentReference(
                vkStream, rootType,
                (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pResolveAttachments =
        (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pResolveAttachments) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pResolveAttachments,
            forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
                unmarshal_VkAttachmentReference(
                    vkStream, rootType,
                    (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
            }
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDepthStencilAttachment =
        (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDepthStencilAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment,
                        sizeof(const VkAttachmentReference));
        unmarshal_VkAttachmentReference(
            vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pDepthStencilAttachment));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments,
                    forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments,
                   forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}

void marshal_VkSubpassDependency(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSubpassDependency* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
    vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask,
                    sizeof(VkPipelineStageFlags));
    vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask,
                    sizeof(VkPipelineStageFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
}

void unmarshal_VkSubpassDependency(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSubpassDependency* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask,
                   sizeof(VkPipelineStageFlags));
    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask,
                   sizeof(VkPipelineStageFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
                   sizeof(VkDependencyFlags));
}

void marshal_VkRenderPassCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkRenderPassCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags,
                    sizeof(VkRenderPassCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
            marshal_VkAttachmentDescription(
                vkStream, rootType,
                (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
            marshal_VkSubpassDescription(
                vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
            marshal_VkSubpassDependency(
                vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
        }
    }
}

void unmarshal_VkRenderPassCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      VkRenderPassCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkRenderPassCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAttachments,
                    forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
            unmarshal_VkAttachmentDescription(
                vkStream, rootType, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSubpasses,
                    forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i) {
            unmarshal_VkSubpassDescription(
                vkStream, rootType, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDependencies,
                    forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i) {
            unmarshal_VkSubpassDependency(
                vkStream, rootType, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
        }
    }
}

void marshal_VkCommandPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkCommandPoolCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags,
                    sizeof(VkCommandPoolCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
}

void unmarshal_VkCommandPoolCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       VkCommandPoolCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkCommandPoolCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
}

void marshal_VkCommandBufferAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkCommandBufferAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool,
                                                            &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
}

void unmarshal_VkCommandBufferAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkCommandBufferAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkCommandPool(
        &cgen_var_0, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
    vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
}

void marshal_VkCommandBufferInheritanceInfo(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkCommandBufferInheritanceInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer,
                                                            &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
    vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
    vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
                    sizeof(VkQueryPipelineStatisticFlags));
}

void unmarshal_VkCommandBufferInheritanceInfo(VulkanStream* vkStream, VkStructureType rootType,
                                              VkCommandBufferInheritanceInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
        &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(
        &cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
    vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
    vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
    vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics,
                   sizeof(VkQueryPipelineStatisticFlags));
}

void marshal_VkCommandBufferBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkCommandBufferBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags,
                    sizeof(VkCommandBufferUsageFlags));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pInheritanceInfo) {
        marshal_VkCommandBufferInheritanceInfo(
            vkStream, rootType,
            (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
    }
}

void unmarshal_VkCommandBufferBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        VkCommandBufferBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags,
                   sizeof(VkCommandBufferUsageFlags));
    // WARNING PTR CHECK
    forUnmarshaling->pInheritanceInfo =
        (const VkCommandBufferInheritanceInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pInheritanceInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pInheritanceInfo,
                        sizeof(const VkCommandBufferInheritanceInfo));
        unmarshal_VkCommandBufferInheritanceInfo(
            vkStream, rootType,
            (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
    }
}

void marshal_VkBufferCopy(VulkanStream* vkStream, VkStructureType rootType,
                          const VkBufferCopy* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkBufferCopy(VulkanStream* vkStream, VkStructureType rootType,
                            VkBufferCopy* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkImageSubresourceLayers(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkImageSubresourceLayers* forMarshaling) {
    (void)rootType;
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}

void unmarshal_VkImageSubresourceLayers(VulkanStream* vkStream, VkStructureType rootType,
                                        VkImageSubresourceLayers* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}

void marshal_VkBufferImageCopy(VulkanStream* vkStream, VkStructureType rootType,
                               const VkBufferImageCopy* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
}

void unmarshal_VkBufferImageCopy(VulkanStream* vkStream, VkStructureType rootType,
                                 VkBufferImageCopy* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
}

void marshal_VkClearColorValue(VulkanStream* vkStream, VkStructureType rootType,
                               const VkClearColorValue* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)forMarshaling->float32, 4 * sizeof(float));
}

void unmarshal_VkClearColorValue(VulkanStream* vkStream, VkStructureType rootType,
                                 VkClearColorValue* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)forUnmarshaling->float32, 4 * sizeof(float));
}

void marshal_VkClearDepthStencilValue(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkClearDepthStencilValue* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->depth, sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
}

void unmarshal_VkClearDepthStencilValue(VulkanStream* vkStream, VkStructureType rootType,
                                        VkClearDepthStencilValue* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->depth, sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->stencil, sizeof(uint32_t));
}

void marshal_VkClearValue(VulkanStream* vkStream, VkStructureType rootType,
                          const VkClearValue* forMarshaling) {
    (void)rootType;
    marshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->color));
}

void unmarshal_VkClearValue(VulkanStream* vkStream, VkStructureType rootType,
                            VkClearValue* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forUnmarshaling->color));
}

void marshal_VkClearAttachment(VulkanStream* vkStream, VkStructureType rootType,
                               const VkClearAttachment* forMarshaling) {
    (void)rootType;
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->write((uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
    marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
}

void unmarshal_VkClearAttachment(VulkanStream* vkStream, VkStructureType rootType,
                                 VkClearAttachment* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachment, sizeof(uint32_t));
    unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
}

void marshal_VkClearRect(VulkanStream* vkStream, VkStructureType rootType,
                         const VkClearRect* forMarshaling) {
    (void)rootType;
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->rect));
    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}

void unmarshal_VkClearRect(VulkanStream* vkStream, VkStructureType rootType,
                           VkClearRect* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->rect));
    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}

void marshal_VkImageBlit(VulkanStream* vkStream, VkStructureType rootType,
                         const VkImageBlit* forMarshaling) {
    (void)rootType;
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
    }
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
    }
}

void unmarshal_VkImageBlit(VulkanStream* vkStream, VkStructureType rootType,
                           VkImageBlit* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
    }
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
    }
}

void marshal_VkImageCopy(VulkanStream* vkStream, VkStructureType rootType,
                         const VkImageCopy* forMarshaling) {
    (void)rootType;
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}

void unmarshal_VkImageCopy(VulkanStream* vkStream, VkStructureType rootType,
                           VkImageCopy* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}

void marshal_VkImageResolve(VulkanStream* vkStream, VkStructureType rootType,
                            const VkImageResolve* forMarshaling) {
    (void)rootType;
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}

void unmarshal_VkImageResolve(VulkanStream* vkStream, VkStructureType rootType,
                              VkImageResolve* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}

void marshal_VkRenderPassBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkRenderPassBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer,
                                                            &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
    vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pClearValues) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i) {
                marshal_VkClearValue(vkStream, rootType,
                                     (const VkClearValue*)(forMarshaling->pClearValues + i));
            }
        }
    }
}

void unmarshal_VkRenderPassBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkRenderPassBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
        &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(
        &cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
    vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pClearValues = (const VkClearValue*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pClearValues) {
        vkStream->alloc((void**)&forUnmarshaling->pClearValues,
                        forUnmarshaling->clearValueCount * sizeof(const VkClearValue));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i) {
                unmarshal_VkClearValue(vkStream, rootType,
                                       (VkClearValue*)(forUnmarshaling->pClearValues + i));
            }
        }
    }
}

#endif
#ifdef VK_VERSION_1_1
void marshal_VkPhysicalDeviceSubgroupProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->supportedStages,
                    sizeof(VkShaderStageFlags));
    vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations,
                    sizeof(VkSubgroupFeatureFlags));
    vkStream->write((VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSubgroupProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubgroupProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->supportedStages,
                   sizeof(VkShaderStageFlags));
    vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->supportedOperations,
                   sizeof(VkSubgroupFeatureFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->quadOperationsInAllStages, sizeof(VkBool32));
}

void marshal_VkBindBufferMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkBindBufferMemoryInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}

void unmarshal_VkBindBufferMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                      VkBindBufferMemoryInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}

void marshal_VkBindImageMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkBindImageMemoryInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}

void unmarshal_VkBindImageMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkBindImageMemoryInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}

void marshal_VkPhysicalDevice16BitStorageFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevice16BitStorageFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevice16BitStorageFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevice16BitStorageFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
}

void marshal_VkMemoryDedicatedRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkMemoryDedicatedRequirements* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}

void unmarshal_VkMemoryDedicatedRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                             VkMemoryDedicatedRequirements* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}

void marshal_VkMemoryDedicatedAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkMemoryDedicatedAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}

void unmarshal_VkMemoryDedicatedAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkMemoryDedicatedAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

void marshal_VkMemoryAllocateFlagsInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkMemoryAllocateFlagsInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}

void unmarshal_VkMemoryAllocateFlagsInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkMemoryAllocateFlagsInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMemoryAllocateFlags*)&forUnmarshaling->flags, sizeof(VkMemoryAllocateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}

void marshal_VkDeviceGroupRenderPassBeginInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceGroupRenderPassBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i) {
            marshal_VkRect2D(vkStream, rootType,
                             (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
        }
    }
}

void unmarshal_VkDeviceGroupRenderPassBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkDeviceGroupRenderPassBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceRenderAreaCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDeviceRenderAreas,
                    forUnmarshaling->deviceRenderAreaCount * sizeof(const VkRect2D));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i) {
            unmarshal_VkRect2D(vkStream, rootType,
                               (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
        }
    }
}

void marshal_VkDeviceGroupCommandBufferBeginInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceGroupCommandBufferBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}

void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}

void marshal_VkDeviceGroupSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkDeviceGroupSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices,
                    forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pCommandBufferDeviceMasks,
                    forMarshaling->commandBufferCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices,
                    forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
}

void unmarshal_VkDeviceGroupSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       VkDeviceGroupSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreDeviceIndices,
                    forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices,
                   forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCommandBufferDeviceMasks,
                    forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pCommandBufferDeviceMasks,
                   forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreDeviceIndices,
                    forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pSignalSemaphoreDeviceIndices,
                   forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
}

void marshal_VkDeviceGroupBindSparseInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDeviceGroupBindSparseInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
}

void unmarshal_VkDeviceGroupBindSparseInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDeviceGroupBindSparseInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->resourceDeviceIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->memoryDeviceIndex, sizeof(uint32_t));
}

void marshal_VkBindBufferMemoryDeviceGroupInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindBufferMemoryDeviceGroupInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
                    forMarshaling->deviceIndexCount * sizeof(const uint32_t));
}

void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices,
                    forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
                   forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
}

void marshal_VkBindImageMemoryDeviceGroupInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindImageMemoryDeviceGroupInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
                    forMarshaling->deviceIndexCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i) {
            marshal_VkRect2D(vkStream, rootType,
                             (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
        }
    }
}

void unmarshal_VkBindImageMemoryDeviceGroupInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkBindImageMemoryDeviceGroupInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices,
                    forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
                   forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSplitInstanceBindRegions,
                    forUnmarshaling->splitInstanceBindRegionCount * sizeof(const VkRect2D));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i) {
            unmarshal_VkRect2D(vkStream, rootType,
                               (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
        }
    }
}

void marshal_VkPhysicalDeviceGroupProperties(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPhysicalDeviceGroupProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
    vkStream->write((VkPhysicalDevice*)forMarshaling->physicalDevices,
                    VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
    vkStream->write((VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceGroupProperties(VulkanStream* vkStream, VkStructureType rootType,
                                               VkPhysicalDeviceGroupProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
    vkStream->read((VkPhysicalDevice*)forUnmarshaling->physicalDevices,
                   VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
    vkStream->read((VkBool32*)&forUnmarshaling->subsetAllocation, sizeof(VkBool32));
}

void marshal_VkDeviceGroupDeviceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDeviceGroupDeviceCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
    if (forMarshaling->physicalDeviceCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->physicalDeviceCount * 8);
        vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(
            forMarshaling->pPhysicalDevices, cgen_var_0, forMarshaling->physicalDeviceCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->physicalDeviceCount * 8);
    }
}

void unmarshal_VkDeviceGroupDeviceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDeviceGroupDeviceCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPhysicalDevices,
                    forUnmarshaling->physicalDeviceCount * sizeof(const VkPhysicalDevice));
    if (forUnmarshaling->physicalDeviceCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->physicalDeviceCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->physicalDeviceCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(
            cgen_var_0, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices,
            forUnmarshaling->physicalDeviceCount);
    }
}

void marshal_VkBufferMemoryRequirementsInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkBufferMemoryRequirementsInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkBufferMemoryRequirementsInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                               VkBufferMemoryRequirementsInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

void marshal_VkImageMemoryRequirementsInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkImageMemoryRequirementsInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkImageMemoryRequirementsInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                              VkImageMemoryRequirementsInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
}

void marshal_VkImageSparseMemoryRequirementsInfo2(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageSparseMemoryRequirementsInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkImageSparseMemoryRequirementsInfo2(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageSparseMemoryRequirementsInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
}

void marshal_VkMemoryRequirements2(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkMemoryRequirements2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkMemoryRequirements(vkStream, rootType,
                                 (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
}

void unmarshal_VkMemoryRequirements2(VulkanStream* vkStream, VkStructureType rootType,
                                     VkMemoryRequirements2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkMemoryRequirements(vkStream, rootType,
                                   (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
}

void marshal_VkSparseImageMemoryRequirements2(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSparseImageMemoryRequirements2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkSparseImageMemoryRequirements(
        vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
}

void unmarshal_VkSparseImageMemoryRequirements2(VulkanStream* vkStream, VkStructureType rootType,
                                                VkSparseImageMemoryRequirements2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkSparseImageMemoryRequirements(
        vkStream, rootType,
        (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
}

void marshal_VkPhysicalDeviceFeatures2(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkPhysicalDeviceFeatures2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkPhysicalDeviceFeatures(vkStream, rootType,
                                     (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
}

void unmarshal_VkPhysicalDeviceFeatures2(VulkanStream* vkStream, VkStructureType rootType,
                                         VkPhysicalDeviceFeatures2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkPhysicalDeviceFeatures(vkStream, rootType,
                                       (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
}

void marshal_VkPhysicalDeviceProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkPhysicalDeviceProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkPhysicalDeviceProperties(vkStream, rootType,
                                       (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
}

void unmarshal_VkPhysicalDeviceProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                           VkPhysicalDeviceProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkPhysicalDeviceProperties(
        vkStream, rootType, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
}

void marshal_VkFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkFormatProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkFormatProperties(vkStream, rootType,
                               (VkFormatProperties*)(&forMarshaling->formatProperties));
}

void unmarshal_VkFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                   VkFormatProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkFormatProperties(vkStream, rootType,
                                 (VkFormatProperties*)(&forUnmarshaling->formatProperties));
}

void marshal_VkImageFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkImageFormatProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
}

void unmarshal_VkImageFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                        VkImageFormatProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
}

void marshal_VkPhysicalDeviceImageFormatInfo2(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageFormatInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
}

void unmarshal_VkPhysicalDeviceImageFormatInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceImageFormatInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
}

void marshal_VkQueueFamilyProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkQueueFamilyProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkQueueFamilyProperties(
        vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
}

void unmarshal_VkQueueFamilyProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                        VkQueueFamilyProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkQueueFamilyProperties(
        vkStream, rootType, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
}

void marshal_VkPhysicalDeviceMemoryProperties2(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkPhysicalDeviceMemoryProperties(
        vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
}

void unmarshal_VkPhysicalDeviceMemoryProperties2(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMemoryProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkPhysicalDeviceMemoryProperties(
        vkStream, rootType,
        (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
}

void marshal_VkSparseImageFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkSparseImageFormatProperties2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
}

void unmarshal_VkSparseImageFormatProperties2(VulkanStream* vkStream, VkStructureType rootType,
                                              VkSparseImageFormatProperties2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
}

void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
}

void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
}

void marshal_VkPhysicalDevicePointClippingProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePointClippingProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
                    sizeof(VkPointClippingBehavior));
}

void unmarshal_VkPhysicalDevicePointClippingProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePointClippingProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior,
                   sizeof(VkPointClippingBehavior));
}

void marshal_VkInputAttachmentAspectReference(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkInputAttachmentAspectReference* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
}

void unmarshal_VkInputAttachmentAspectReference(VulkanStream* vkStream, VkStructureType rootType,
                                                VkInputAttachmentAspectReference* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentIndex, sizeof(uint32_t));
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
}

void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i) {
            marshal_VkInputAttachmentAspectReference(
                vkStream, rootType,
                (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
        }
    }
}

void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->aspectReferenceCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pAspectReferences,
        forUnmarshaling->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i) {
            unmarshal_VkInputAttachmentAspectReference(
                vkStream, rootType,
                (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
        }
    }
}

void marshal_VkImageViewUsageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkImageViewUsageCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
}

void unmarshal_VkImageViewUsageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          VkImageViewUsageCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
}

void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin,
                    sizeof(VkTessellationDomainOrigin));
}

void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin,
                   sizeof(VkTessellationDomainOrigin));
}

void marshal_VkRenderPassMultiviewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkRenderPassMultiviewCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pViewMasks,
                    forMarshaling->subpassCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    vkStream->write((const int32_t*)forMarshaling->pViewOffsets,
                    forMarshaling->dependencyCount * sizeof(const int32_t));
    vkStream->write((uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pCorrelationMasks,
                    forMarshaling->correlationMaskCount * sizeof(const uint32_t));
}

void unmarshal_VkRenderPassMultiviewCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                               VkRenderPassMultiviewCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pViewMasks,
                    forUnmarshaling->subpassCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pViewMasks,
                   forUnmarshaling->subpassCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pViewOffsets,
                    forUnmarshaling->dependencyCount * sizeof(const int32_t));
    vkStream->read((int32_t*)forUnmarshaling->pViewOffsets,
                   forUnmarshaling->dependencyCount * sizeof(const int32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->correlationMaskCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCorrelationMasks,
                    forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pCorrelationMasks,
                   forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
}

void marshal_VkPhysicalDeviceMultiviewFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultiviewFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiviewFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewGeometryShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewTessellationShader, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMultiviewProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceMultiviewProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiviewProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceVariablePointersFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVariablePointersFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVariablePointersFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceProtectedMemoryProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
}

void marshal_VkDeviceQueueInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                const VkDeviceQueueInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags,
                    sizeof(VkDeviceQueueCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->queueIndex, sizeof(uint32_t));
}

void unmarshal_VkDeviceQueueInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                  VkDeviceQueueInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkDeviceQueueCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->queueIndex, sizeof(uint32_t));
}

void marshal_VkProtectedSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkProtectedSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
}

void unmarshal_VkProtectedSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkProtectedSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->protectedSubmit, sizeof(VkBool32));
}

void marshal_VkSamplerYcbcrConversionCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerYcbcrConversionCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel,
                    sizeof(VkSamplerYcbcrModelConversion));
    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
    marshal_VkComponentMapping(vkStream, rootType,
                               (VkComponentMapping*)(&forMarshaling->components));
    vkStream->write((VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
    vkStream->write((VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
    vkStream->write((VkFilter*)&forMarshaling->chromaFilter, sizeof(VkFilter));
    vkStream->write((VkBool32*)&forMarshaling->forceExplicitReconstruction, sizeof(VkBool32));
}

void unmarshal_VkSamplerYcbcrConversionCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSamplerYcbcrConversionCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->ycbcrModel,
                   sizeof(VkSamplerYcbcrModelConversion));
    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
    unmarshal_VkComponentMapping(vkStream, rootType,
                                 (VkComponentMapping*)(&forUnmarshaling->components));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->xChromaOffset, sizeof(VkChromaLocation));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->yChromaOffset, sizeof(VkChromaLocation));
    vkStream->read((VkFilter*)&forUnmarshaling->chromaFilter, sizeof(VkFilter));
    vkStream->read((VkBool32*)&forUnmarshaling->forceExplicitReconstruction, sizeof(VkBool32));
}

void marshal_VkSamplerYcbcrConversionInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkSamplerYcbcrConversionInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion,
                                                                       &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkSamplerYcbcrConversionInfo(VulkanStream* vkStream, VkStructureType rootType,
                                            VkSamplerYcbcrConversionInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(
        &cgen_var_0, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
}

void marshal_VkBindImagePlaneMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkBindImagePlaneMemoryInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
                    sizeof(VkImageAspectFlagBits));
}

void unmarshal_VkBindImagePlaneMemoryInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          VkBindImagePlaneMemoryInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
                   sizeof(VkImageAspectFlagBits));
}

void marshal_VkImagePlaneMemoryRequirementsInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImagePlaneMemoryRequirementsInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
                    sizeof(VkImageAspectFlagBits));
}

void unmarshal_VkImagePlaneMemoryRequirementsInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImagePlaneMemoryRequirementsInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
                   sizeof(VkImageAspectFlagBits));
}

void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
}

void marshal_VkSamplerYcbcrConversionImageFormatProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount,
                    sizeof(uint32_t));
}

void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount,
                   sizeof(uint32_t));
}

void marshal_VkDescriptorUpdateTemplateEntry(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkDescriptorUpdateTemplateEntry* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->offset;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->stride;
    vkStream->putBe64(cgen_var_1);
}

void unmarshal_VkDescriptorUpdateTemplateEntry(VulkanStream* vkStream, VkStructureType rootType,
                                               VkDescriptorUpdateTemplateEntry* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
    forUnmarshaling->offset = (size_t)vkStream->getBe64();
    forUnmarshaling->stride = (size_t)vkStream->getBe64();
}

void marshal_VkDescriptorUpdateTemplateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorUpdateTemplateCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags,
                    sizeof(VkDescriptorUpdateTemplateCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i) {
            marshal_VkDescriptorUpdateTemplateEntry(
                vkStream, rootType,
                (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries +
                                                         i));
        }
    }
    vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType,
                    sizeof(VkDescriptorUpdateTemplateType));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
        &forMarshaling->descriptorSetLayout, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout,
                                                               &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
}

void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkDescriptorUpdateTemplateCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDescriptorUpdateEntries,
                    forUnmarshaling->descriptorUpdateEntryCount *
                        sizeof(const VkDescriptorUpdateTemplateEntry));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i) {
            unmarshal_VkDescriptorUpdateTemplateEntry(
                vkStream, rootType,
                (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
        }
    }
    vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType,
                   sizeof(VkDescriptorUpdateTemplateType));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
        &cgen_var_0, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_1, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
}

void marshal_VkExternalMemoryProperties(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkExternalMemoryProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures,
                    sizeof(VkExternalMemoryFeatureFlags));
    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlags));
    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlags));
}

void unmarshal_VkExternalMemoryProperties(VulkanStream* vkStream, VkStructureType rootType,
                                          VkExternalMemoryProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkExternalMemoryFeatureFlags*)&forUnmarshaling->externalMemoryFeatures,
                   sizeof(VkExternalMemoryFeatureFlags));
    vkStream->read(
        (VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
        sizeof(VkExternalMemoryHandleTypeFlags));
    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlags));
}

void marshal_VkPhysicalDeviceExternalImageFormatInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void marshal_VkExternalImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkExternalImageFormatProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExternalMemoryProperties(
        vkStream, rootType,
        (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}

void unmarshal_VkExternalImageFormatProperties(VulkanStream* vkStream, VkStructureType rootType,
                                               VkExternalImageFormatProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExternalMemoryProperties(
        vkStream, rootType,
        (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
}

void marshal_VkPhysicalDeviceExternalBufferInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalBufferInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkPhysicalDeviceExternalBufferInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalBufferInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void marshal_VkExternalBufferProperties(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkExternalBufferProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExternalMemoryProperties(
        vkStream, rootType,
        (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}

void unmarshal_VkExternalBufferProperties(VulkanStream* vkStream, VkStructureType rootType,
                                          VkExternalBufferProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExternalMemoryProperties(
        vkStream, rootType,
        (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
}

void marshal_VkPhysicalDeviceIDProperties(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkPhysicalDeviceIDProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceIDProperties(VulkanStream* vkStream, VkStructureType rootType,
                                            VkPhysicalDeviceIDProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint8_t*)forUnmarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceNodeMask, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
}

void marshal_VkExternalMemoryImageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkExternalMemoryImageCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlags));
}

void unmarshal_VkExternalMemoryImageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                               VkExternalMemoryImageCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlags));
}

void marshal_VkExternalMemoryBufferCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExternalMemoryBufferCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlags));
}

void unmarshal_VkExternalMemoryBufferCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkExternalMemoryBufferCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlags));
}

void marshal_VkExportMemoryAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkExportMemoryAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlags));
}

void unmarshal_VkExportMemoryAllocateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                          VkExportMemoryAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlags));
}

void marshal_VkPhysicalDeviceExternalFenceInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalFenceInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalFenceHandleTypeFlagBits));
}

void unmarshal_VkPhysicalDeviceExternalFenceInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalFenceInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalFenceHandleTypeFlagBits));
}

void marshal_VkExternalFenceProperties(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkExternalFenceProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
                    sizeof(VkExternalFenceHandleTypeFlags));
    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
                    sizeof(VkExternalFenceHandleTypeFlags));
    vkStream->write((VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures,
                    sizeof(VkExternalFenceFeatureFlags));
}

void unmarshal_VkExternalFenceProperties(VulkanStream* vkStream, VkStructureType rootType,
                                         VkExternalFenceProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
                   sizeof(VkExternalFenceHandleTypeFlags));
    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
                   sizeof(VkExternalFenceHandleTypeFlags));
    vkStream->read((VkExternalFenceFeatureFlags*)&forUnmarshaling->externalFenceFeatures,
                   sizeof(VkExternalFenceFeatureFlags));
}

void marshal_VkExportFenceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkExportFenceCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes,
                    sizeof(VkExternalFenceHandleTypeFlags));
}

void unmarshal_VkExportFenceCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       VkExportFenceCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalFenceHandleTypeFlags));
}

void marshal_VkExportSemaphoreCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkExportSemaphoreCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes,
                    sizeof(VkExternalSemaphoreHandleTypeFlags));
}

void unmarshal_VkExportSemaphoreCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkExportSemaphoreCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalSemaphoreHandleTypeFlags));
}

void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

void marshal_VkExternalSemaphoreProperties(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkExternalSemaphoreProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write(
        (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
        sizeof(VkExternalSemaphoreHandleTypeFlags));
    vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
                    sizeof(VkExternalSemaphoreHandleTypeFlags));
    vkStream->write((VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures,
                    sizeof(VkExternalSemaphoreFeatureFlags));
}

void unmarshal_VkExternalSemaphoreProperties(VulkanStream* vkStream, VkStructureType rootType,
                                             VkExternalSemaphoreProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read(
        (VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
        sizeof(VkExternalSemaphoreHandleTypeFlags));
    vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
                   sizeof(VkExternalSemaphoreHandleTypeFlags));
    vkStream->read((VkExternalSemaphoreFeatureFlags*)&forUnmarshaling->externalSemaphoreFeatures,
                   sizeof(VkExternalSemaphoreFeatureFlags));
}

void marshal_VkPhysicalDeviceMaintenance3Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance3Properties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceMaintenance3Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMaintenance3Properties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}

void marshal_VkDescriptorSetLayoutSupport(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkDescriptorSetLayoutSupport* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
}

void unmarshal_VkDescriptorSetLayoutSupport(VulkanStream* vkStream, VkStructureType rootType,
                                            VkDescriptorSetLayoutSupport* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->supported, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
}

#endif
#ifdef VK_VERSION_1_2
void marshal_VkPhysicalDeviceVulkan11Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan11Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVulkan11Features(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceVulkan11Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewGeometryShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewTessellationShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceVulkan11Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan11Properties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->subgroupSupportedStages,
                    sizeof(VkShaderStageFlags));
    vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->subgroupSupportedOperations,
                    sizeof(VkSubgroupFeatureFlags));
    vkStream->write((VkBool32*)&forMarshaling->subgroupQuadOperationsInAllStages, sizeof(VkBool32));
    vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
                    sizeof(VkPointClippingBehavior));
    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceVulkan11Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVulkan11Properties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint8_t*)forUnmarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceNodeMask, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->subgroupSupportedStages,
                   sizeof(VkShaderStageFlags));
    vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->subgroupSupportedOperations,
                   sizeof(VkSubgroupFeatureFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->subgroupQuadOperationsInAllStages,
                   sizeof(VkBool32));
    vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior,
                   sizeof(VkPointClippingBehavior));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}

void marshal_VkPhysicalDeviceVulkan12Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan12Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->samplerMirrorClampToEdge, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->drawIndirectCount, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorIndexing, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->samplerFilterMinmax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->imagelessFramebuffer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->hostQueryReset, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->timelineSemaphore, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderOutputViewportIndex, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderOutputLayer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->subgroupBroadcastDynamicId, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVulkan12Features(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceVulkan12Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->samplerMirrorClampToEdge, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->drawIndirectCount, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt8, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorIndexing, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->samplerFilterMinmax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->scalarBlockLayout, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->imagelessFramebuffer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->hostQueryReset, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->timelineSemaphore, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModel, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderOutputViewportIndex, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderOutputLayer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->subgroupBroadcastDynamicId, sizeof(VkBool32));
}

void marshal_VkConformanceVersion(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkConformanceVersion* forMarshaling) {
    (void)rootType;
    vkStream->write((uint8_t*)&forMarshaling->major, sizeof(uint8_t));
    vkStream->write((uint8_t*)&forMarshaling->minor, sizeof(uint8_t));
    vkStream->write((uint8_t*)&forMarshaling->subminor, sizeof(uint8_t));
    vkStream->write((uint8_t*)&forMarshaling->patch, sizeof(uint8_t));
}

void unmarshal_VkConformanceVersion(VulkanStream* vkStream, VkStructureType rootType,
                                    VkConformanceVersion* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint8_t*)&forUnmarshaling->major, sizeof(uint8_t));
    vkStream->read((uint8_t*)&forUnmarshaling->minor, sizeof(uint8_t));
    vkStream->read((uint8_t*)&forUnmarshaling->subminor, sizeof(uint8_t));
    vkStream->read((uint8_t*)&forUnmarshaling->patch, sizeof(uint8_t));
}

void marshal_VkPhysicalDeviceVulkan12Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan12Properties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
    vkStream->write((char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    marshal_VkConformanceVersion(vkStream, rootType,
                                 (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
    vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
                    sizeof(VkShaderFloatControlsIndependence));
    vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
                    sizeof(VkShaderFloatControlsIndependence));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
                    sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
                    sizeof(uint32_t));
    vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
                    sizeof(VkResolveModeFlags));
    vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
                    sizeof(VkResolveModeFlags));
    vkStream->write((VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->independentResolve, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
    vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference,
                    sizeof(uint64_t));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferIntegerColorSampleCounts,
                    sizeof(VkSampleCountFlags));
}

void unmarshal_VkPhysicalDeviceVulkan12Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVulkan12Properties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDriverId*)&forUnmarshaling->driverID, sizeof(VkDriverId));
    vkStream->read((char*)forUnmarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    unmarshal_VkConformanceVersion(vkStream, rootType,
                                   (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
    vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence,
                   sizeof(VkShaderFloatControlsIndependence));
    vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence,
                   sizeof(VkShaderFloatControlsIndependence));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools,
                   sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
                   sizeof(uint32_t));
    vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes,
                   sizeof(VkResolveModeFlags));
    vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes,
                   sizeof(VkResolveModeFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->independentResolveNone, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->independentResolve, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping,
                   sizeof(VkBool32));
    vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference,
                   sizeof(uint64_t));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferIntegerColorSampleCounts,
                   sizeof(VkSampleCountFlags));
}

void marshal_VkImageFormatListCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkImageFormatListCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
    vkStream->write((const VkFormat*)forMarshaling->pViewFormats,
                    forMarshaling->viewFormatCount * sizeof(const VkFormat));
}

void unmarshal_VkImageFormatListCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkImageFormatListCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pViewFormats,
                    forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
    vkStream->read((VkFormat*)forUnmarshaling->pViewFormats,
                   forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
}

void marshal_VkAttachmentDescription2(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkAttachmentDescription2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags,
                    sizeof(VkAttachmentDescriptionFlags));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp,
                    sizeof(VkAttachmentStoreOp));
    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
    vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
}

void unmarshal_VkAttachmentDescription2(VulkanStream* vkStream, VkStructureType rootType,
                                        VkAttachmentDescription2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags,
                   sizeof(VkAttachmentDescriptionFlags));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp,
                   sizeof(VkAttachmentLoadOp));
    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp,
                   sizeof(VkAttachmentStoreOp));
    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
    vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
}

void marshal_VkAttachmentReference2(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkAttachmentReference2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
    vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
}

void unmarshal_VkAttachmentReference2(VulkanStream* vkStream, VkStructureType rootType,
                                      VkAttachmentReference2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
    vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
}

void marshal_VkSubpassDescription2(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkSubpassDescription2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags,
                    sizeof(VkSubpassDescriptionFlags));
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
            marshal_VkAttachmentReference2(
                vkStream, rootType,
                (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
            marshal_VkAttachmentReference2(
                vkStream, rootType,
                (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pResolveAttachments) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
                marshal_VkAttachmentReference2(
                    vkStream, rootType,
                    (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i));
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pDepthStencilAttachment) {
        marshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment));
    }
    vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments,
                    forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}

void unmarshal_VkSubpassDescription2(VulkanStream* vkStream, VkStructureType rootType,
                                     VkSubpassDescription2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags,
                   sizeof(VkSubpassDescriptionFlags));
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pInputAttachments,
                    forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i) {
            unmarshal_VkAttachmentReference2(
                vkStream, rootType,
                (VkAttachmentReference2*)(forUnmarshaling->pInputAttachments + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pColorAttachments,
                    forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
            unmarshal_VkAttachmentReference2(
                vkStream, rootType,
                (VkAttachmentReference2*)(forUnmarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pResolveAttachments =
        (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pResolveAttachments) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pResolveAttachments,
            forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
                unmarshal_VkAttachmentReference2(
                    vkStream, rootType,
                    (VkAttachmentReference2*)(forUnmarshaling->pResolveAttachments + i));
            }
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDepthStencilAttachment =
        (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDepthStencilAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment,
                        sizeof(const VkAttachmentReference2));
        unmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilAttachment));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments,
                    forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments,
                   forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}

void marshal_VkSubpassDependency2(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkSubpassDependency2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
    vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask,
                    sizeof(VkPipelineStageFlags));
    vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask,
                    sizeof(VkPipelineStageFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
    vkStream->write((int32_t*)&forMarshaling->viewOffset, sizeof(int32_t));
}

void unmarshal_VkSubpassDependency2(VulkanStream* vkStream, VkStructureType rootType,
                                    VkSubpassDependency2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask,
                   sizeof(VkPipelineStageFlags));
    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask,
                   sizeof(VkPipelineStageFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
                   sizeof(VkDependencyFlags));
    vkStream->read((int32_t*)&forUnmarshaling->viewOffset, sizeof(int32_t));
}

void marshal_VkRenderPassCreateInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkRenderPassCreateInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags,
                    sizeof(VkRenderPassCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
            marshal_VkAttachmentDescription2(
                vkStream, rootType,
                (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
            marshal_VkSubpassDescription2(
                vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
            marshal_VkSubpassDependency2(
                vkStream, rootType,
                (const VkSubpassDependency2*)(forMarshaling->pDependencies + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pCorrelatedViewMasks,
                    forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
}

void unmarshal_VkRenderPassCreateInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                       VkRenderPassCreateInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkRenderPassCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAttachments,
                    forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
            unmarshal_VkAttachmentDescription2(
                vkStream, rootType, (VkAttachmentDescription2*)(forUnmarshaling->pAttachments + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSubpasses,
                    forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i) {
            unmarshal_VkSubpassDescription2(
                vkStream, rootType, (VkSubpassDescription2*)(forUnmarshaling->pSubpasses + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDependencies,
                    forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i) {
            unmarshal_VkSubpassDependency2(
                vkStream, rootType, (VkSubpassDependency2*)(forUnmarshaling->pDependencies + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->correlatedViewMaskCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCorrelatedViewMasks,
                    forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pCorrelatedViewMasks,
                   forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
}

void marshal_VkSubpassBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                const VkSubpassBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
}

void unmarshal_VkSubpassBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                  VkSubpassBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSubpassContents*)&forUnmarshaling->contents, sizeof(VkSubpassContents));
}

void marshal_VkSubpassEndInfo(VulkanStream* vkStream, VkStructureType rootType,
                              const VkSubpassEndInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}

void unmarshal_VkSubpassEndInfo(VulkanStream* vkStream, VkStructureType rootType,
                                VkSubpassEndInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
}

void marshal_VkPhysicalDevice8BitStorageFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevice8BitStorageFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevice8BitStorageFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevice8BitStorageFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceDriverProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDriverProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
    vkStream->write((char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    marshal_VkConformanceVersion(vkStream, rootType,
                                 (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
}

void unmarshal_VkPhysicalDeviceDriverProperties(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceDriverProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDriverId*)&forUnmarshaling->driverID, sizeof(VkDriverId));
    vkStream->read((char*)forUnmarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    unmarshal_VkConformanceVersion(vkStream, rootType,
                                   (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
}

void marshal_VkPhysicalDeviceShaderAtomicInt64Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt8, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFloatControlsProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFloatControlsProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
                    sizeof(VkShaderFloatControlsIndependence));
    vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
                    sizeof(VkShaderFloatControlsIndependence));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat64, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFloatControlsProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFloatControlsProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence,
                   sizeof(VkShaderFloatControlsIndependence));
    vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence,
                   sizeof(VkShaderFloatControlsIndependence));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormFlushToZeroFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTEFloat64, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
}

void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pBindingFlags;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pBindingFlags) {
        vkStream->write((const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags,
                        forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
    }
}

void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pBindingFlags =
        (const VkDescriptorBindingFlags*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pBindingFlags) {
        vkStream->alloc((void**)&forUnmarshaling->pBindingFlags,
                        forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
        vkStream->read((VkDescriptorBindingFlags*)forUnmarshaling->pBindingFlags,
                       forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
    }
}

void marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceDescriptorIndexingProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
                    sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools,
                   sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
                   sizeof(uint32_t));
}

void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pDescriptorCounts,
                    forMarshaling->descriptorSetCount * sizeof(const uint32_t));
}

void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDescriptorCounts,
                    forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts,
                   forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
}

void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
}

void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
}

void marshal_VkSubpassDescriptionDepthStencilResolve(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSubpassDescriptionDepthStencilResolve* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkResolveModeFlagBits*)&forMarshaling->depthResolveMode,
                    sizeof(VkResolveModeFlagBits));
    vkStream->write((VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode,
                    sizeof(VkResolveModeFlagBits));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilResolveAttachment;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pDepthStencilResolveAttachment) {
        marshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment));
    }
}

void unmarshal_VkSubpassDescriptionDepthStencilResolve(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSubpassDescriptionDepthStencilResolve* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->depthResolveMode,
                   sizeof(VkResolveModeFlagBits));
    vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->stencilResolveMode,
                   sizeof(VkResolveModeFlagBits));
    // WARNING PTR CHECK
    forUnmarshaling->pDepthStencilResolveAttachment =
        (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDepthStencilResolveAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilResolveAttachment,
                        sizeof(const VkAttachmentReference2));
        unmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilResolveAttachment));
    }
}

void marshal_VkPhysicalDeviceDepthStencilResolveProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
                    sizeof(VkResolveModeFlags));
    vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
                    sizeof(VkResolveModeFlags));
    vkStream->write((VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->independentResolve, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes,
                   sizeof(VkResolveModeFlags));
    vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes,
                   sizeof(VkResolveModeFlags));
    vkStream->read((VkBool32*)&forUnmarshaling->independentResolveNone, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->independentResolve, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->scalarBlockLayout, sizeof(VkBool32));
}

void marshal_VkImageStencilUsageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkImageStencilUsageCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageUsageFlags*)&forMarshaling->stencilUsage, sizeof(VkImageUsageFlags));
}

void unmarshal_VkImageStencilUsageCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkImageStencilUsageCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->stencilUsage, sizeof(VkImageUsageFlags));
}

void marshal_VkSamplerReductionModeCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerReductionModeCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSamplerReductionMode*)&forMarshaling->reductionMode,
                    sizeof(VkSamplerReductionMode));
}

void unmarshal_VkSamplerReductionModeCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkSamplerReductionModeCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSamplerReductionMode*)&forUnmarshaling->reductionMode,
                   sizeof(VkSamplerReductionMode));
}

void marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModel, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->imagelessFramebuffer, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->imagelessFramebuffer, sizeof(VkBool32));
}

void marshal_VkFramebufferAttachmentImageInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkFramebufferAttachmentImageInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
    vkStream->write((const VkFormat*)forMarshaling->pViewFormats,
                    forMarshaling->viewFormatCount * sizeof(const VkFormat));
}

void unmarshal_VkFramebufferAttachmentImageInfo(VulkanStream* vkStream, VkStructureType rootType,
                                                VkFramebufferAttachmentImageInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pViewFormats,
                    forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
    vkStream->read((VkFormat*)forUnmarshaling->pViewFormats,
                   forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
}

void marshal_VkFramebufferAttachmentsCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkFramebufferAttachmentsCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->attachmentImageInfoCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i) {
            marshal_VkFramebufferAttachmentImageInfo(
                vkStream, rootType,
                (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos +
                                                          i));
        }
    }
}

void unmarshal_VkFramebufferAttachmentsCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkFramebufferAttachmentsCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentImageInfoCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pAttachmentImageInfos,
        forUnmarshaling->attachmentImageInfoCount * sizeof(const VkFramebufferAttachmentImageInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentImageInfoCount; ++i) {
            unmarshal_VkFramebufferAttachmentImageInfo(
                vkStream, rootType,
                (VkFramebufferAttachmentImageInfo*)(forUnmarshaling->pAttachmentImageInfos + i));
        }
    }
}

void marshal_VkRenderPassAttachmentBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkRenderPassAttachmentBeginInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    if (forMarshaling->attachmentCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->attachmentCount * 8);
        vkStream->handleMapping()->mapHandles_VkImageView_u64(
            forMarshaling->pAttachments, cgen_var_0, forMarshaling->attachmentCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->attachmentCount * 8);
    }
}

void unmarshal_VkRenderPassAttachmentBeginInfo(VulkanStream* vkStream, VkStructureType rootType,
                                               VkRenderPassAttachmentBeginInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAttachments,
                    forUnmarshaling->attachmentCount * sizeof(const VkImageView));
    if (forUnmarshaling->attachmentCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->attachmentCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->attachmentCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkImageView(
            cgen_var_0, (VkImageView*)forUnmarshaling->pAttachments,
            forUnmarshaling->attachmentCount);
    }
}

void marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
}

void marshal_VkAttachmentReferenceStencilLayout(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAttachmentReferenceStencilLayout* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageLayout*)&forMarshaling->stencilLayout, sizeof(VkImageLayout));
}

void unmarshal_VkAttachmentReferenceStencilLayout(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAttachmentReferenceStencilLayout* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageLayout*)&forUnmarshaling->stencilLayout, sizeof(VkImageLayout));
}

void marshal_VkAttachmentDescriptionStencilLayout(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAttachmentDescriptionStencilLayout* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageLayout*)&forMarshaling->stencilInitialLayout, sizeof(VkImageLayout));
    vkStream->write((VkImageLayout*)&forMarshaling->stencilFinalLayout, sizeof(VkImageLayout));
}

void unmarshal_VkAttachmentDescriptionStencilLayout(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAttachmentDescriptionStencilLayout* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageLayout*)&forUnmarshaling->stencilInitialLayout, sizeof(VkImageLayout));
    vkStream->read((VkImageLayout*)&forUnmarshaling->stencilFinalLayout, sizeof(VkImageLayout));
}

void marshal_VkPhysicalDeviceHostQueryResetFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->hostQueryReset, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->hostQueryReset, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->timelineSemaphore, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->timelineSemaphore, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference,
                    sizeof(uint64_t));
}

void unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference,
                   sizeof(uint64_t));
}

void marshal_VkSemaphoreTypeCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSemaphoreTypeCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSemaphoreType*)&forMarshaling->semaphoreType, sizeof(VkSemaphoreType));
    vkStream->write((uint64_t*)&forMarshaling->initialValue, sizeof(uint64_t));
}

void unmarshal_VkSemaphoreTypeCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkSemaphoreTypeCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSemaphoreType*)&forUnmarshaling->semaphoreType, sizeof(VkSemaphoreType));
    vkStream->read((uint64_t*)&forUnmarshaling->initialValue, sizeof(uint64_t));
}

void marshal_VkTimelineSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkTimelineSemaphoreSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pWaitSemaphoreValues) {
        vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues,
                        forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
    }
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pSignalSemaphoreValues) {
        vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues,
                        forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
    }
}

void unmarshal_VkTimelineSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkTimelineSemaphoreSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pWaitSemaphoreValues) {
        vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreValues,
                        forUnmarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
        vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues,
                       forUnmarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSignalSemaphoreValues) {
        vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreValues,
                        forUnmarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
        vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues,
                       forUnmarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
    }
}

void marshal_VkSemaphoreWaitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSemaphoreWaitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSemaphoreWaitFlags*)&forMarshaling->flags, sizeof(VkSemaphoreWaitFlags));
    vkStream->write((uint32_t*)&forMarshaling->semaphoreCount, sizeof(uint32_t));
    if (forMarshaling->semaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->semaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pSemaphores, cgen_var_0, forMarshaling->semaphoreCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->semaphoreCount * 8);
    }
    vkStream->write((const uint64_t*)forMarshaling->pValues,
                    forMarshaling->semaphoreCount * sizeof(const uint64_t));
}

void unmarshal_VkSemaphoreWaitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSemaphoreWaitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSemaphoreWaitFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreWaitFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->semaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSemaphores,
                    forUnmarshaling->semaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->semaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->semaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->semaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_0, (VkSemaphore*)forUnmarshaling->pSemaphores,
            forUnmarshaling->semaphoreCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pValues,
                    forUnmarshaling->semaphoreCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pValues,
                   forUnmarshaling->semaphoreCount * sizeof(const uint64_t));
}

void marshal_VkSemaphoreSignalInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkSemaphoreSignalInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
}

void unmarshal_VkSemaphoreSignalInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkSemaphoreSignalInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
}

void marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
}

void marshal_VkBufferDeviceAddressInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkBufferDeviceAddressInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkBufferDeviceAddressInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkBufferDeviceAddressInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

void marshal_VkBufferOpaqueCaptureAddressCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}

void unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}

void marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}

void unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}

void marshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}

#endif
#ifdef VK_VERSION_1_3
void marshal_VkPhysicalDeviceVulkan13Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan13Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVulkan13Features(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceVulkan13Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->synchronization2, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->dynamicRendering, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->maintenance4, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceVulkan13Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan13Properties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
                    sizeof(VkShaderStageFlags));
    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
                    sizeof(uint32_t));
    vkStream->write(
        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
        sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformTotalSize, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling
            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
                    sizeof(VkDeviceSize));
    vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
                    sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
                    sizeof(VkDeviceSize));
    vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
                    sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceVulkan13Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVulkan13Properties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
                   sizeof(VkShaderStageFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformTotalSize, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling
            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
                   sizeof(VkDeviceSize));
    vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
                   sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
                   sizeof(VkDeviceSize));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
                   sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxBufferSize, sizeof(VkDeviceSize));
}

void marshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkPipelineCreationFeedback* forMarshaling) {
    (void)rootType;
    vkStream->write((VkPipelineCreationFeedbackFlags*)&forMarshaling->flags,
                    sizeof(VkPipelineCreationFeedbackFlags));
    vkStream->write((uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
}

void unmarshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
                                          VkPipelineCreationFeedback* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkPipelineCreationFeedbackFlags*)&forUnmarshaling->flags,
                   sizeof(VkPipelineCreationFeedbackFlags));
    vkStream->read((uint64_t*)&forUnmarshaling->duration, sizeof(uint64_t));
}

void marshal_VkPipelineCreationFeedbackCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineCreationFeedbackCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkPipelineCreationFeedback(
        vkStream, rootType,
        (VkPipelineCreationFeedback*)(forMarshaling->pPipelineCreationFeedback));
    vkStream->write((uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount,
                    sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i) {
            marshal_VkPipelineCreationFeedback(
                vkStream, rootType,
                (VkPipelineCreationFeedback*)(forMarshaling->pPipelineStageCreationFeedbacks + i));
        }
    }
}

void unmarshal_VkPipelineCreationFeedbackCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineCreationFeedbackCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pPipelineCreationFeedback,
                    sizeof(VkPipelineCreationFeedback));
    unmarshal_VkPipelineCreationFeedback(
        vkStream, rootType,
        (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineCreationFeedback));
    vkStream->read((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount,
                   sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pPipelineStageCreationFeedbacks,
        forUnmarshaling->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedback));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount;
             ++i) {
            unmarshal_VkPipelineCreationFeedback(
                vkStream, rootType,
                (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineStageCreationFeedbacks +
                                              i));
        }
    }
}

void marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderTerminateInvocationFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderTerminateInvocationFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkPhysicalDeviceToolProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((char*)forMarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->write((VkToolPurposeFlags*)&forMarshaling->purposes, sizeof(VkToolPurposeFlags));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}

void unmarshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
                                              VkPhysicalDeviceToolProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((char*)forUnmarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    vkStream->read((VkToolPurposeFlags*)&forUnmarshaling->purposes, sizeof(VkToolPurposeFlags));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}

void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
}

void marshal_VkPhysicalDevicePrivateDataFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePrivateDataFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePrivateDataFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePrivateDataFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
}

void marshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDevicePrivateDataCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
}

void unmarshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDevicePrivateDataCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
}

void marshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkPrivateDataSlotCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPrivateDataSlotCreateFlags*)&forMarshaling->flags,
                    sizeof(VkPrivateDataSlotCreateFlags));
}

void unmarshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           VkPrivateDataSlotCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPrivateDataSlotCreateFlags*)&forUnmarshaling->flags,
                   sizeof(VkPrivateDataSlotCreateFlags));
}

void marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineCreationCacheControlFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineCreationCacheControlFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
}

void marshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                              const VkMemoryBarrier2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
}

void unmarshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                                VkMemoryBarrier2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
}

void marshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkBufferMemoryBarrier2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                                      VkBufferMemoryBarrier2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkImageMemoryBarrier2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    marshal_VkImageSubresourceRange(vkStream, rootType,
                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}

void unmarshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
                                     VkImageMemoryBarrier2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    unmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}

void marshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
                              const VkDependencyInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
    vkStream->write((uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
            marshal_VkMemoryBarrier2(vkStream, rootType,
                                     (const VkMemoryBarrier2*)(forMarshaling->pMemoryBarriers + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
            marshal_VkBufferMemoryBarrier2(
                vkStream, rootType,
                (const VkBufferMemoryBarrier2*)(forMarshaling->pBufferMemoryBarriers + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
            marshal_VkImageMemoryBarrier2(
                vkStream, rootType,
                (const VkImageMemoryBarrier2*)(forMarshaling->pImageMemoryBarriers + i));
        }
    }
}

void unmarshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
                                VkDependencyInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
                   sizeof(VkDependencyFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->memoryBarrierCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pMemoryBarriers,
                    forUnmarshaling->memoryBarrierCount * sizeof(const VkMemoryBarrier2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
            unmarshal_VkMemoryBarrier2(vkStream, rootType,
                                       (VkMemoryBarrier2*)(forUnmarshaling->pMemoryBarriers + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pBufferMemoryBarriers,
        forUnmarshaling->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
            unmarshal_VkBufferMemoryBarrier2(
                vkStream, rootType,
                (VkBufferMemoryBarrier2*)(forUnmarshaling->pBufferMemoryBarriers + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pImageMemoryBarriers,
                    forUnmarshaling->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
            unmarshal_VkImageMemoryBarrier2(
                vkStream, rootType,
                (VkImageMemoryBarrier2*)(forUnmarshaling->pImageMemoryBarriers + i));
        }
    }
}

void marshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkSemaphoreSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->stageMask,
                    sizeof(VkPipelineStageFlags2));
    vkStream->write((uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
}

void unmarshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                     VkSemaphoreSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->stageMask,
                   sizeof(VkPipelineStageFlags2));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndex, sizeof(uint32_t));
}

void marshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkCommandBufferSubmitInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->commandBuffer,
                                                              &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}

void unmarshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkCommandBufferSubmitInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
        &cgen_var_0, (VkCommandBuffer*)&forUnmarshaling->commandBuffer, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}

void marshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
                           const VkSubmitInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSubmitFlags*)&forMarshaling->flags, sizeof(VkSubmitFlags));
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
            marshal_VkSemaphoreSubmitInfo(
                vkStream, rootType,
                (const VkSemaphoreSubmitInfo*)(forMarshaling->pWaitSemaphoreInfos + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
            marshal_VkCommandBufferSubmitInfo(
                vkStream, rootType,
                (const VkCommandBufferSubmitInfo*)(forMarshaling->pCommandBufferInfos + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
            marshal_VkSemaphoreSubmitInfo(
                vkStream, rootType,
                (const VkSemaphoreSubmitInfo*)(forMarshaling->pSignalSemaphoreInfos + i));
        }
    }
}

void unmarshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
                             VkSubmitInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSubmitFlags*)&forUnmarshaling->flags, sizeof(VkSubmitFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreInfos,
                    forUnmarshaling->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
            unmarshal_VkSemaphoreSubmitInfo(
                vkStream, rootType,
                (VkSemaphoreSubmitInfo*)(forUnmarshaling->pWaitSemaphoreInfos + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferInfoCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pCommandBufferInfos,
        forUnmarshaling->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
            unmarshal_VkCommandBufferSubmitInfo(
                vkStream, rootType,
                (VkCommandBufferSubmitInfo*)(forUnmarshaling->pCommandBufferInfos + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pSignalSemaphoreInfos,
        forUnmarshaling->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
            unmarshal_VkSemaphoreSubmitInfo(
                vkStream, rootType,
                (VkSemaphoreSubmitInfo*)(forUnmarshaling->pSignalSemaphoreInfos + i));
        }
    }
}

void marshal_VkPhysicalDeviceSynchronization2Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSynchronization2Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSynchronization2Features(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSynchronization2Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->synchronization2, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceImageRobustnessFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageRobustnessFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageRobustnessFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageRobustnessFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
}

void marshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
                           const VkBufferCopy2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
                             VkBufferCopy2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
                               const VkCopyBufferInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkBufferCopy2(vkStream, rootType,
                                  (const VkBufferCopy2*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                 VkCopyBufferInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkBufferCopy2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkBufferCopy2(vkStream, rootType,
                                    (VkBufferCopy2*)(forUnmarshaling->pRegions + i));
        }
    }
}

void marshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
                          const VkImageCopy2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}

void unmarshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
                            VkImageCopy2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}

void marshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                              const VkCopyImageInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkImageCopy2(vkStream, rootType,
                                 (const VkImageCopy2*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                VkCopyImageInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkImageCopy2(vkStream, rootType,
                                   (VkImageCopy2*)(forUnmarshaling->pRegions + i));
        }
    }
}

void marshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
                                const VkBufferImageCopy2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
}

void unmarshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
                                  VkBufferImageCopy2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
}

void marshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkCopyBufferToImageInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkBufferImageCopy2(vkStream, rootType,
                                       (const VkBufferImageCopy2*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                        VkCopyBufferToImageInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkBufferImageCopy2(vkStream, rootType,
                                         (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i));
        }
    }
}

void marshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkCopyImageToBufferInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkBufferImageCopy2(vkStream, rootType,
                                       (const VkBufferImageCopy2*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                        VkCopyImageToBufferInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkBufferImageCopy2(vkStream, rootType,
                                         (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i));
        }
    }
}

void marshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
                          const VkImageBlit2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
    }
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
    }
}

void unmarshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
                            VkImageBlit2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
    }
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
    }
}

void marshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                              const VkBlitImageInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkImageBlit2(vkStream, rootType,
                                 (const VkImageBlit2*)(forMarshaling->pRegions + i));
        }
    }
    vkStream->write((VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
}

void unmarshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                VkBlitImageInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkImageBlit2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkImageBlit2(vkStream, rootType,
                                   (VkImageBlit2*)(forUnmarshaling->pRegions + i));
        }
    }
    vkStream->read((VkFilter*)&forUnmarshaling->filter, sizeof(VkFilter));
}

void marshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
                             const VkImageResolve2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}

void unmarshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
                               VkImageResolve2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}

void marshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkResolveImageInfo2* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkImageResolve2(vkStream, rootType,
                                    (const VkImageResolve2*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
                                   VkResolveImageInfo2* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkImageResolve2));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkImageResolve2(vkStream, rootType,
                                      (VkImageResolve2*)(forUnmarshaling->pRegions + i));
        }
    }
}

void marshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupSizeControlFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubgroupSizeControlFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceSubgroupSizeControlProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupSizeControlProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
                    sizeof(VkShaderStageFlags));
}

void unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubgroupSizeControlProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
                   sizeof(VkShaderStageFlags));
}

void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->requiredSubgroupSize, sizeof(uint32_t));
}

void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->requiredSubgroupSize, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceInlineUniformBlockFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceInlineUniformBlockFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceInlineUniformBlockFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceInlineUniformBlockProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceInlineUniformBlockProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
                    sizeof(uint32_t));
    vkStream->write(
        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
        sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceInlineUniformBlockProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
                   sizeof(uint32_t));
}

void marshal_VkWriteDescriptorSetInlineUniformBlock(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkWriteDescriptorSetInlineUniformBlock* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->dataSize, sizeof(uint32_t));
    vkStream->write((const void*)forMarshaling->pData,
                    forMarshaling->dataSize * sizeof(const uint8_t));
}

void unmarshal_VkWriteDescriptorSetInlineUniformBlock(
    VulkanStream* vkStream, VkStructureType rootType,
    VkWriteDescriptorSetInlineUniformBlock* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->dataSize, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pData,
                    forUnmarshaling->dataSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pData,
                   forUnmarshaling->dataSize * sizeof(const uint8_t));
}

void marshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorPoolInlineUniformBlockCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
}

void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorPoolInlineUniformBlockCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
}

void marshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkRenderingAttachmentInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    vkStream->write((VkResolveModeFlagBits*)&forMarshaling->resolveMode,
                    sizeof(VkResolveModeFlagBits));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->resolveImageView,
                                                          &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->resolveImageLayout, sizeof(VkImageLayout));
    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
}

void unmarshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
                                         VkRenderingAttachmentInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
    vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode,
                   sizeof(VkResolveModeFlagBits));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_1, (VkImageView*)&forUnmarshaling->resolveImageView, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->resolveImageLayout, sizeof(VkImageLayout));
    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
}

void marshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
                             const VkRenderingInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRenderingFlags*)&forMarshaling->flags, sizeof(VkRenderingFlags));
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
            marshal_VkRenderingAttachmentInfo(
                vkStream, rootType,
                (const VkRenderingAttachmentInfo*)(forMarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pDepthAttachment) {
        marshal_VkRenderingAttachmentInfo(
            vkStream, rootType,
            (const VkRenderingAttachmentInfo*)(forMarshaling->pDepthAttachment));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pStencilAttachment) {
        marshal_VkRenderingAttachmentInfo(
            vkStream, rootType,
            (const VkRenderingAttachmentInfo*)(forMarshaling->pStencilAttachment));
    }
}

void unmarshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
                               VkRenderingInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRenderingFlags*)&forUnmarshaling->flags, sizeof(VkRenderingFlags));
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pColorAttachments,
        forUnmarshaling->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
            unmarshal_VkRenderingAttachmentInfo(
                vkStream, rootType,
                (VkRenderingAttachmentInfo*)(forUnmarshaling->pColorAttachments + i));
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDepthAttachment =
        (const VkRenderingAttachmentInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDepthAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pDepthAttachment,
                        sizeof(const VkRenderingAttachmentInfo));
        unmarshal_VkRenderingAttachmentInfo(
            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pDepthAttachment));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pStencilAttachment =
        (const VkRenderingAttachmentInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStencilAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pStencilAttachment,
                        sizeof(const VkRenderingAttachmentInfo));
        unmarshal_VkRenderingAttachmentInfo(
            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pStencilAttachment));
    }
}

void marshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkPipelineRenderingCreateInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pColorAttachmentFormats) {
        vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
                        forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
    }
    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
}

void unmarshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
                                             VkPipelineRenderingCreateInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pColorAttachmentFormats = (const VkFormat*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pColorAttachmentFormats) {
        vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
                        forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
        vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
                       forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
}

void marshal_VkPhysicalDeviceDynamicRenderingFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDynamicRenderingFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDynamicRenderingFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->dynamicRendering, sizeof(VkBool32));
}

void marshal_VkCommandBufferInheritanceRenderingInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceRenderingInfo* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRenderingFlags*)&forMarshaling->flags, sizeof(VkRenderingFlags));
    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
                    forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
                    sizeof(VkSampleCountFlagBits));
}

void unmarshal_VkCommandBufferInheritanceRenderingInfo(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCommandBufferInheritanceRenderingInfo* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRenderingFlags*)&forUnmarshaling->flags, sizeof(VkRenderingFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
    vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
                   forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
                   sizeof(VkSampleCountFlagBits));
}

void marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerDotProductFeatures* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderIntegerDotProductFeatures* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerDotProductProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling
            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling
                        ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderIntegerDotProductProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
        sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling
            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling
                       ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTexelBufferAlignmentProperties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
                    sizeof(VkDeviceSize));
    vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
                    sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
                    sizeof(VkDeviceSize));
    vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTexelBufferAlignmentProperties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
                   sizeof(VkDeviceSize));
    vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
                   sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
                   sizeof(VkDeviceSize));
    vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
                   sizeof(VkBool32));
}

void marshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkFormatProperties3* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->linearTilingFeatures,
                    sizeof(VkFormatFeatureFlags2));
    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->optimalTilingFeatures,
                    sizeof(VkFormatFeatureFlags2));
    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->bufferFeatures,
                    sizeof(VkFormatFeatureFlags2));
}

void unmarshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
                                   VkFormatProperties3* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->linearTilingFeatures,
                   sizeof(VkFormatFeatureFlags2));
    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->optimalTilingFeatures,
                   sizeof(VkFormatFeatureFlags2));
    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->bufferFeatures,
                   sizeof(VkFormatFeatureFlags2));
}

void marshal_VkPhysicalDeviceMaintenance4Features(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance4Features* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMaintenance4Features(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMaintenance4Features* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->maintenance4, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMaintenance4Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance4Properties* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceMaintenance4Properties(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMaintenance4Properties* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxBufferSize, sizeof(VkDeviceSize));
}

void marshal_VkDeviceBufferMemoryRequirements(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceBufferMemoryRequirements* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkBufferCreateInfo(vkStream, rootType,
                               (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo));
}

void unmarshal_VkDeviceBufferMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                                VkDeviceBufferMemoryRequirements* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkBufferCreateInfo));
    unmarshal_VkBufferCreateInfo(vkStream, rootType,
                                 (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo));
}

void marshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkDeviceImageMemoryRequirements* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageCreateInfo(vkStream, rootType,
                              (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
                    sizeof(VkImageAspectFlagBits));
}

void unmarshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
                                               VkDeviceImageMemoryRequirements* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
    unmarshal_VkImageCreateInfo(vkStream, rootType,
                                (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
                   sizeof(VkImageAspectFlagBits));
}

#endif
#ifdef VK_KHR_surface
void marshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkSurfaceCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent));
    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
                    sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
                    sizeof(VkCompositeAlphaFlagsKHR));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
                    sizeof(VkImageUsageFlags));
}

void unmarshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        VkSurfaceCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->currentExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
                   sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha,
                   sizeof(VkCompositeAlphaFlagsKHR));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags,
                   sizeof(VkImageUsageFlags));
}

void marshal_VkSurfaceFormatKHR(VulkanStream* vkStream, VkStructureType rootType,
                                const VkSurfaceFormatKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
}

void unmarshal_VkSurfaceFormatKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  VkSurfaceFormatKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->colorSpace, sizeof(VkColorSpaceKHR));
}

#endif
#ifdef VK_KHR_swapchain
void marshal_VkSwapchainCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkSwapchainCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkSwapchainCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
    vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent));
    vkStream->write((uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
    vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pQueueFamilyIndices) {
        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
                        forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha,
                    sizeof(VkCompositeAlphaFlagBitsKHR));
    vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
    vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
    uint64_t cgen_var_2;
    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain,
                                                             &cgen_var_2, 1);
    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
}

void unmarshal_VkSwapchainCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        VkSwapchainCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkSwapchainCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(
        &cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
    vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
    vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->imageExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->imageArrayLayers, sizeof(uint32_t));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
    vkStream->read((VkSharingMode*)&forUnmarshaling->imageSharingMode, sizeof(VkSharingMode));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pQueueFamilyIndices) {
        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices,
                        forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
                       forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->preTransform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha,
                   sizeof(VkCompositeAlphaFlagBitsKHR));
    vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
    vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
    uint64_t cgen_var_2;
    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
        &cgen_var_2, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
}

void marshal_VkPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                              const VkPresentInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    if (forMarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
            forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
    }
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    if (forMarshaling->swapchainCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->swapchainCount * 8);
        vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(
            forMarshaling->pSwapchains, cgen_var_1, forMarshaling->swapchainCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->swapchainCount * 8);
    }
    vkStream->write((const uint32_t*)forMarshaling->pImageIndices,
                    forMarshaling->swapchainCount * sizeof(const uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pResults;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pResults) {
        vkStream->write((VkResult*)forMarshaling->pResults,
                        forMarshaling->swapchainCount * sizeof(VkResult));
    }
}

void unmarshal_VkPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                VkPresentInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores,
                    forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
    if (forUnmarshaling->waitSemaphoreCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
            cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
            forUnmarshaling->waitSemaphoreCount);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSwapchains,
                    forUnmarshaling->swapchainCount * sizeof(const VkSwapchainKHR));
    if (forUnmarshaling->swapchainCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->swapchainCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->swapchainCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
            cgen_var_1, (VkSwapchainKHR*)forUnmarshaling->pSwapchains,
            forUnmarshaling->swapchainCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pImageIndices,
                    forUnmarshaling->swapchainCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pImageIndices,
                   forUnmarshaling->swapchainCount * sizeof(const uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pResults = (VkResult*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pResults) {
        vkStream->alloc((void**)&forUnmarshaling->pResults,
                        forUnmarshaling->swapchainCount * sizeof(VkResult));
        vkStream->read((VkResult*)forUnmarshaling->pResults,
                       forUnmarshaling->swapchainCount * sizeof(VkResult));
    }
}

void marshal_VkImageSwapchainCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkImageSwapchainCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkImageSwapchainCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkImageSwapchainCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
        &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
}

void marshal_VkBindImageMemorySwapchainInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindImageMemorySwapchainInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
}

void unmarshal_VkBindImageMemorySwapchainInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindImageMemorySwapchainInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
        &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
}

void marshal_VkAcquireNextImageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkAcquireNextImageInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_1,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    uint64_t cgen_var_2;
    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_2, 1);
    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}

void unmarshal_VkAcquireNextImageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkAcquireNextImageInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
        &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
    vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_1, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    uint64_t cgen_var_2;
    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_2,
                                                      (VkFence*)&forUnmarshaling->fence, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}

void marshal_VkDeviceGroupPresentCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)forMarshaling->presentMask,
                    VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
    vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
                    sizeof(VkDeviceGroupPresentModeFlagsKHR));
}

void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)forUnmarshaling->presentMask,
                   VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
    vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes,
                   sizeof(VkDeviceGroupPresentModeFlagsKHR));
}

void marshal_VkDeviceGroupPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDeviceGroupPresentInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pDeviceMasks,
                    forMarshaling->swapchainCount * sizeof(const uint32_t));
    vkStream->write((VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode,
                    sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
}

void unmarshal_VkDeviceGroupPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDeviceGroupPresentInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDeviceMasks,
                    forUnmarshaling->swapchainCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks,
                   forUnmarshaling->swapchainCount * sizeof(const uint32_t));
    vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode,
                   sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
}

void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
                    sizeof(VkDeviceGroupPresentModeFlagsKHR));
}

void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes,
                   sizeof(VkDeviceGroupPresentModeFlagsKHR));
}

#endif
#ifdef VK_KHR_display
void marshal_VkDisplayModeParametersKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDisplayModeParametersKHR* forMarshaling) {
    (void)rootType;
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->visibleRegion));
    vkStream->write((uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
}

void unmarshal_VkDisplayModeParametersKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDisplayModeParametersKHR* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->visibleRegion));
    vkStream->read((uint32_t*)&forUnmarshaling->refreshRate, sizeof(uint32_t));
}

void marshal_VkDisplayModeCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDisplayModeCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkDisplayModeCreateFlagsKHR));
    marshal_VkDisplayModeParametersKHR(vkStream, rootType,
                                       (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}

void unmarshal_VkDisplayModeCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDisplayModeCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkDisplayModeCreateFlagsKHR));
    unmarshal_VkDisplayModeParametersKHR(
        vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}

void marshal_VkDisplayModePropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDisplayModePropertiesKHR* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode,
                                                               &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    marshal_VkDisplayModeParametersKHR(vkStream, rootType,
                                       (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}

void unmarshal_VkDisplayModePropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDisplayModePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
        &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
    unmarshal_VkDisplayModeParametersKHR(
        vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}

void marshal_VkDisplayPlaneCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDisplayPlaneCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha,
                    sizeof(VkDisplayPlaneAlphaFlagsKHR));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSrcExtent));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minDstPosition));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxDstPosition));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minDstExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent));
}

void unmarshal_VkDisplayPlaneCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDisplayPlaneCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDisplayPlaneAlphaFlagsKHR*)&forUnmarshaling->supportedAlpha,
                   sizeof(VkDisplayPlaneAlphaFlagsKHR));
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->minSrcPosition));
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->maxSrcPosition));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minSrcExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxSrcExtent));
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->minDstPosition));
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->maxDstPosition));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minDstExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxDstExtent));
}

void marshal_VkDisplayPlanePropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDisplayPlanePropertiesKHR* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay,
                                                           &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
}

void unmarshal_VkDisplayPlanePropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDisplayPlanePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(
        &cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
}

void marshal_VkDisplayPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkDisplayPropertiesKHR* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->putString(forMarshaling->displayName);
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalDimensions));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalResolution));
    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
                    sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->write((VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
}

void unmarshal_VkDisplayPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      VkDisplayPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(
        &cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->display, 1);
    vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
                   sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->read((VkBool32*)&forUnmarshaling->planeReorderPossible, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->persistentContent, sizeof(VkBool32));
}

void marshal_VkDisplaySurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDisplaySurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkDisplaySurfaceCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode,
                                                               &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->write((float*)&forMarshaling->globalAlpha, sizeof(float));
    vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode,
                    sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent));
}

void unmarshal_VkDisplaySurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDisplaySurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkDisplaySurfaceCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
        &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->read((float*)&forUnmarshaling->globalAlpha, sizeof(float));
    vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode,
                   sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->imageExtent));
}

#endif
#ifdef VK_KHR_display_swapchain
void marshal_VkDisplayPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkDisplayPresentInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->srcRect));
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->dstRect));
    vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
}

void unmarshal_VkDisplayPresentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkDisplayPresentInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->srcRect));
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->dstRect));
    vkStream->read((VkBool32*)&forUnmarshaling->persistent, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_xlib_surface
void marshal_VkXlibSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkXlibSurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkXlibSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dpy;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->dpy) {
        vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
    }
    vkStream->write((Window*)&forMarshaling->window, sizeof(Window));
}

void unmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkXlibSurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkXlibSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    forUnmarshaling->dpy = (Display*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->dpy) {
        vkStream->alloc((void**)&forUnmarshaling->dpy, sizeof(Display));
        vkStream->read((Display*)forUnmarshaling->dpy, sizeof(Display));
    }
    vkStream->read((Window*)&forUnmarshaling->window, sizeof(Window));
}

#endif
#ifdef VK_KHR_xcb_surface
void marshal_VkXcbSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkXcbSurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;

    // This struct should never be marshaled / unmarshaled.
    __builtin_trap();
}

void unmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkXcbSurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;

    // This struct should never be marshaled / unmarshaled.
    __builtin_trap();
}

#endif
#ifdef VK_KHR_wayland_surface
void marshal_VkWaylandSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkWaylandSurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkWaylandSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->display;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->display) {
        vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->surface;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->surface) {
        vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
    }
}

void unmarshal_VkWaylandSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkWaylandSurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkWaylandSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    forUnmarshaling->display = (wl_display*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->display) {
        vkStream->alloc((void**)&forUnmarshaling->display, sizeof(wl_display));
        vkStream->read((wl_display*)forUnmarshaling->display, sizeof(wl_display));
    }
    // WARNING PTR CHECK
    forUnmarshaling->surface = (wl_surface*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->surface) {
        vkStream->alloc((void**)&forUnmarshaling->surface, sizeof(wl_surface));
        vkStream->read((wl_surface*)forUnmarshaling->surface, sizeof(wl_surface));
    }
}

#endif
#ifdef VK_KHR_android_surface
void marshal_VkAndroidSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkAndroidSurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkAndroidSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->window) {
        vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
    }
}

void unmarshal_VkAndroidSurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkAndroidSurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkAndroidSurfaceCreateFlagsKHR));
    // WARNING PTR CHECK
    forUnmarshaling->window = (ANativeWindow*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->window) {
        vkStream->alloc((void**)&forUnmarshaling->window, sizeof(ANativeWindow));
        vkStream->read((ANativeWindow*)forUnmarshaling->window, sizeof(ANativeWindow));
    }
}

#endif
#ifdef VK_KHR_win32_surface
void marshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkWin32SurfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkWin32SurfaceCreateFlagsKHR));
    vkStream->write((HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
    vkStream->write((HWND*)&forMarshaling->hwnd, sizeof(HWND));
}

void unmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkWin32SurfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkWin32SurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkWin32SurfaceCreateFlagsKHR));
    vkStream->read((HINSTANCE*)&forUnmarshaling->hinstance, sizeof(HINSTANCE));
    vkStream->read((HWND*)&forUnmarshaling->hwnd, sizeof(HWND));
}

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void marshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueueFamilyQueryResultStatusPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->queryResultStatusSupport, sizeof(VkBool32));
}

void unmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueueFamilyQueryResultStatusPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->queryResultStatusSupport, sizeof(VkBool32));
}

void marshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkQueueFamilyVideoPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations,
                    sizeof(VkVideoCodecOperationFlagsKHR));
}

void unmarshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkQueueFamilyVideoPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoCodecOperationFlagsKHR*)&forUnmarshaling->videoCodecOperations,
                   sizeof(VkVideoCodecOperationFlagsKHR));
}

void marshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkVideoProfileInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation,
                    sizeof(VkVideoCodecOperationFlagBitsKHR));
    vkStream->write((VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling,
                    sizeof(VkVideoChromaSubsamplingFlagsKHR));
    vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth,
                    sizeof(VkVideoComponentBitDepthFlagsKHR));
    vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth,
                    sizeof(VkVideoComponentBitDepthFlagsKHR));
}

void unmarshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     VkVideoProfileInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoCodecOperationFlagBitsKHR*)&forUnmarshaling->videoCodecOperation,
                   sizeof(VkVideoCodecOperationFlagBitsKHR));
    vkStream->read((VkVideoChromaSubsamplingFlagsKHR*)&forUnmarshaling->chromaSubsampling,
                   sizeof(VkVideoChromaSubsamplingFlagsKHR));
    vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->lumaBitDepth,
                   sizeof(VkVideoComponentBitDepthFlagsKHR));
    vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->chromaBitDepth,
                   sizeof(VkVideoComponentBitDepthFlagsKHR));
}

void marshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkVideoProfileListInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->profileCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->profileCount; ++i) {
            marshal_VkVideoProfileInfoKHR(
                vkStream, rootType, (const VkVideoProfileInfoKHR*)(forMarshaling->pProfiles + i));
        }
    }
}

void unmarshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkVideoProfileListInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->profileCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pProfiles,
                    forUnmarshaling->profileCount * sizeof(const VkVideoProfileInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->profileCount; ++i) {
            unmarshal_VkVideoProfileInfoKHR(
                vkStream, rootType, (VkVideoProfileInfoKHR*)(forUnmarshaling->pProfiles + i));
        }
    }
}

void marshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkVideoCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoCapabilityFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoCapabilityFlagsKHR));
    vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment,
                    sizeof(VkDeviceSize));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->pictureAccessGranularity));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minCodedExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent));
    vkStream->write((uint32_t*)&forMarshaling->maxDpbSlots, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxActiveReferencePictures, sizeof(uint32_t));
    marshal_VkExtensionProperties(vkStream, rootType,
                                  (VkExtensionProperties*)(&forMarshaling->stdHeaderVersion));
}

void unmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      VkVideoCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoCapabilityFlagsKHR));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferSizeAlignment,
                   sizeof(VkDeviceSize));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->pictureAccessGranularity));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minCodedExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxCodedExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDpbSlots, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, sizeof(uint32_t));
    unmarshal_VkExtensionProperties(vkStream, rootType,
                                    (VkExtensionProperties*)(&forUnmarshaling->stdHeaderVersion));
}

void marshal_VkPhysicalDeviceVideoFormatInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
}

void unmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVideoFormatInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
}

void marshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkVideoFormatPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    marshal_VkComponentMapping(vkStream, rootType,
                               (VkComponentMapping*)(&forMarshaling->componentMapping));
    vkStream->write((VkImageCreateFlags*)&forMarshaling->imageCreateFlags,
                    sizeof(VkImageCreateFlags));
    vkStream->write((VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
    vkStream->write((VkImageTiling*)&forMarshaling->imageTiling, sizeof(VkImageTiling));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsageFlags, sizeof(VkImageUsageFlags));
}

void unmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkVideoFormatPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    unmarshal_VkComponentMapping(vkStream, rootType,
                                 (VkComponentMapping*)(&forUnmarshaling->componentMapping));
    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->imageCreateFlags,
                   sizeof(VkImageCreateFlags));
    vkStream->read((VkImageType*)&forUnmarshaling->imageType, sizeof(VkImageType));
    vkStream->read((VkImageTiling*)&forUnmarshaling->imageTiling, sizeof(VkImageTiling));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsageFlags,
                   sizeof(VkImageUsageFlags));
}

void marshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkVideoPictureResourceInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->codedOffset));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent));
    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageViewBinding,
                                                          &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoPictureResourceInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->codedOffset));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageViewBinding, 1);
}

void marshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkVideoReferenceSlotInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((int32_t*)&forMarshaling->slotIndex, sizeof(int32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPictureResource;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pPictureResource) {
        marshal_VkVideoPictureResourceInfoKHR(
            vkStream, rootType,
            (const VkVideoPictureResourceInfoKHR*)(forMarshaling->pPictureResource));
    }
}

void unmarshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkVideoReferenceSlotInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((int32_t*)&forUnmarshaling->slotIndex, sizeof(int32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pPictureResource =
        (const VkVideoPictureResourceInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pPictureResource) {
        vkStream->alloc((void**)&forUnmarshaling->pPictureResource,
                        sizeof(const VkVideoPictureResourceInfoKHR));
        unmarshal_VkVideoPictureResourceInfoKHR(
            vkStream, rootType,
            (VkVideoPictureResourceInfoKHR*)(forUnmarshaling->pPictureResource));
    }
}

void marshal_VkVideoSessionMemoryRequirementsKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoSessionMemoryRequirementsKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
    marshal_VkMemoryRequirements(vkStream, rootType,
                                 (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
}

void unmarshal_VkVideoSessionMemoryRequirementsKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoSessionMemoryRequirementsKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryBindIndex, sizeof(uint32_t));
    unmarshal_VkMemoryRequirements(vkStream, rootType,
                                   (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
}

void marshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkBindVideoSessionMemoryInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->memorySize, sizeof(VkDeviceSize));
}

void unmarshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkBindVideoSessionMemoryInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryBindIndex, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memorySize, sizeof(VkDeviceSize));
}

void marshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkVideoSessionCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->write((VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoSessionCreateFlagsKHR));
    marshal_VkVideoProfileInfoKHR(vkStream, rootType,
                                  (const VkVideoProfileInfoKHR*)(forMarshaling->pVideoProfile));
    vkStream->write((VkFormat*)&forMarshaling->pictureFormat, sizeof(VkFormat));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent));
    vkStream->write((VkFormat*)&forMarshaling->referencePictureFormat, sizeof(VkFormat));
    vkStream->write((uint32_t*)&forMarshaling->maxDpbSlots, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxActiveReferencePictures, sizeof(uint32_t));
    marshal_VkExtensionProperties(vkStream, rootType,
                                  (const VkExtensionProperties*)(forMarshaling->pStdHeaderVersion));
}

void unmarshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkVideoSessionCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->read((VkVideoSessionCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoSessionCreateFlagsKHR));
    vkStream->alloc((void**)&forUnmarshaling->pVideoProfile, sizeof(const VkVideoProfileInfoKHR));
    unmarshal_VkVideoProfileInfoKHR(vkStream, rootType,
                                    (VkVideoProfileInfoKHR*)(forUnmarshaling->pVideoProfile));
    vkStream->read((VkFormat*)&forUnmarshaling->pictureFormat, sizeof(VkFormat));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxCodedExtent));
    vkStream->read((VkFormat*)&forUnmarshaling->referencePictureFormat, sizeof(VkFormat));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDpbSlots, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdHeaderVersion,
                    sizeof(const VkExtensionProperties));
    unmarshal_VkExtensionProperties(vkStream, rootType,
                                    (VkExtensionProperties*)(forUnmarshaling->pStdHeaderVersion));
}

void marshal_VkVideoSessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoSessionParametersCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoSessionParametersCreateFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoSessionParametersCreateFlagsKHR));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSessionParametersTemplate;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSession;
    vkStream->putBe64(cgen_var_1);
}

void unmarshal_VkVideoSessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoSessionParametersCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoSessionParametersCreateFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoSessionParametersCreateFlagsKHR));
    forUnmarshaling->videoSessionParametersTemplate =
        (VkVideoSessionParametersKHR)vkStream->getBe64();
    forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
}

void marshal_VkVideoSessionParametersUpdateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoSessionParametersUpdateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->updateSequenceCount, sizeof(uint32_t));
}

void unmarshal_VkVideoSessionParametersUpdateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoSessionParametersUpdateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->updateSequenceCount, sizeof(uint32_t));
}

void marshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkVideoBeginCodingInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoBeginCodingFlagsKHR));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSession;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSessionParameters;
    vkStream->putBe64(cgen_var_1);
    vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
            marshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
        }
    }
}

void unmarshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkVideoBeginCodingInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoBeginCodingFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoBeginCodingFlagsKHR));
    forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
    forUnmarshaling->videoSessionParameters = (VkVideoSessionParametersKHR)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pReferenceSlots,
        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
            unmarshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
        }
    }
}

void marshal_VkVideoEndCodingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkVideoEndCodingInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEndCodingFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoEndCodingFlagsKHR));
}

void unmarshal_VkVideoEndCodingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkVideoEndCodingInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEndCodingFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoEndCodingFlagsKHR));
}

void marshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkVideoCodingControlInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoCodingControlFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoCodingControlFlagsKHR));
}

void unmarshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkVideoCodingControlInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoCodingControlFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoCodingControlFlagsKHR));
}

#endif
#ifdef VK_KHR_video_decode_queue
void marshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkVideoDecodeCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoDecodeCapabilityFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoDecodeCapabilityFlagsKHR));
}

void unmarshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                            VkVideoDecodeCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoDecodeCapabilityFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoDecodeCapabilityFlagsKHR));
}

void marshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkVideoDecodeUsageInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoDecodeUsageFlagsKHR*)&forMarshaling->videoUsageHints,
                    sizeof(VkVideoDecodeUsageFlagsKHR));
}

void unmarshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkVideoDecodeUsageInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoDecodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints,
                   sizeof(VkVideoDecodeUsageFlagsKHR));
}

void marshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkVideoDecodeInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoDecodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoDecodeFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferRange, sizeof(VkDeviceSize));
    marshal_VkVideoPictureResourceInfoKHR(
        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forMarshaling->dstPictureResource));
    marshal_VkVideoReferenceSlotInfoKHR(
        vkStream, rootType,
        (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pSetupReferenceSlot));
    vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
            marshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
        }
    }
}

void unmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    VkVideoDecodeInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoDecodeFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoDecodeFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferRange, sizeof(VkDeviceSize));
    unmarshal_VkVideoPictureResourceInfoKHR(
        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->dstPictureResource));
    vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
                    sizeof(const VkVideoReferenceSlotInfoKHR));
    unmarshal_VkVideoReferenceSlotInfoKHR(
        vkStream, rootType, (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot));
    vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pReferenceSlots,
        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
            unmarshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
        }
    }
}

#endif
#ifdef VK_KHR_video_decode_h264
void marshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH264ProfileInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
                    sizeof(StdVideoH264ProfileIdc));
    vkStream->write((VkVideoDecodeH264PictureLayoutFlagBitsKHR*)&forMarshaling->pictureLayout,
                    sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR));
}

void unmarshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH264ProfileInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
                   sizeof(StdVideoH264ProfileIdc));
    vkStream->read((VkVideoDecodeH264PictureLayoutFlagBitsKHR*)&forUnmarshaling->pictureLayout,
                   sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR));
}

void marshal_VkVideoDecodeH264CapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264CapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH264LevelIdc*)&forMarshaling->maxLevelIdc,
                    sizeof(StdVideoH264LevelIdc));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity));
}

void unmarshal_VkVideoDecodeH264CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoDecodeH264CapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH264LevelIdc*)&forUnmarshaling->maxLevelIdc,
                   sizeof(StdVideoH264LevelIdc));
    unmarshal_VkOffset2D(vkStream, rootType,
                         (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity));
}

void marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersAddInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
    vkStream->write((const StdVideoH264SequenceParameterSet*)forMarshaling->pStdSPSs,
                    forMarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
    vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pStdPPSs,
                    forMarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
}

void unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoDecodeH264SessionParametersAddInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
    vkStream->read((StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs,
                   forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
    vkStream->read((StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs,
                   forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
}

void marshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pParametersAddInfo) {
        marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
            vkStream, rootType,
            (const VkVideoDecodeH264SessionParametersAddInfoKHR*)(forMarshaling
                                                                      ->pParametersAddInfo));
    }
}

void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoDecodeH264SessionParametersCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pParametersAddInfo =
        (const VkVideoDecodeH264SessionParametersAddInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pParametersAddInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
                        sizeof(const VkVideoDecodeH264SessionParametersAddInfoKHR));
        unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
            vkStream, rootType,
            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo));
    }
}

void marshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH264PictureInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
                    sizeof(const StdVideoDecodeH264PictureInfo));
    vkStream->write((uint32_t*)&forMarshaling->sliceCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pSliceOffsets,
                    forMarshaling->sliceCount * sizeof(const uint32_t));
}

void unmarshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH264PictureInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                    sizeof(const StdVideoDecodeH264PictureInfo));
    vkStream->read((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
                   sizeof(const StdVideoDecodeH264PictureInfo));
    vkStream->read((uint32_t*)&forUnmarshaling->sliceCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSliceOffsets,
                    forUnmarshaling->sliceCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pSliceOffsets,
                   forUnmarshaling->sliceCount * sizeof(const uint32_t));
}

void marshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH264DpbSlotInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoDecodeH264ReferenceInfo));
}

void unmarshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH264DpbSlotInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoDecodeH264ReferenceInfo));
    vkStream->read((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
                   sizeof(const StdVideoDecodeH264ReferenceInfo));
}

#endif
#ifdef VK_KHR_dynamic_rendering
void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
}

void unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
}

void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}

void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}

void marshal_VkAttachmentSampleCountInfoAMD(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkAttachmentSampleCountInfoAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentSamples;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pColorAttachmentSamples) {
        vkStream->write((const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
                        forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
    }
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
                    sizeof(VkSampleCountFlagBits));
}

void unmarshal_VkAttachmentSampleCountInfoAMD(VulkanStream* vkStream, VkStructureType rootType,
                                              VkAttachmentSampleCountInfoAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pColorAttachmentSamples =
        (const VkSampleCountFlagBits*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pColorAttachmentSamples) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pColorAttachmentSamples,
            forUnmarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
        vkStream->read((VkSampleCountFlagBits*)forUnmarshaling->pColorAttachmentSamples,
                       forUnmarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
    }
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->depthStencilAttachmentSamples,
                   sizeof(VkSampleCountFlagBits));
}

void marshal_VkMultiviewPerViewAttributesInfoNVX(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMultiviewPerViewAttributesInfoNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->perViewAttributes, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
}

void unmarshal_VkMultiviewPerViewAttributesInfoNVX(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->perViewAttributes, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
#endif
#ifdef VK_KHR_device_group
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
#endif
#ifdef VK_KHR_external_memory_capabilities
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportMemoryWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkImportMemoryWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkImportMemoryWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkExportMemoryWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExportMemoryWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAttributes) {
        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
                        sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkExportMemoryWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkExportMemoryWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAttributes) {
        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
                       sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkMemoryWin32HandlePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryWin32HandlePropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkMemoryWin32HandlePropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkMemoryWin32HandlePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkMemoryGetWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkMemoryGetWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkMemoryGetWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkMemoryGetWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_external_memory_fd
void marshal_VkImportMemoryFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkImportMemoryFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}

void unmarshal_VkImportMemoryFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkImportMemoryFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}

void marshal_VkMemoryFdPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkMemoryFdPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkMemoryFdPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkMemoryFdPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkMemoryGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkMemoryGetFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkMemoryGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    VkMemoryGetFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
    if (forMarshaling->acquireCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->acquireCount * 8);
        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
            forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->acquireCount * 8);
    }
    vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys,
                    forMarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts,
                    forMarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
    if (forMarshaling->releaseCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->releaseCount * 8);
        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
            forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->releaseCount * 8);
    }
    vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys,
                    forMarshaling->releaseCount * sizeof(const uint64_t));
}

void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs,
                    forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
    if (forUnmarshaling->acquireCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->acquireCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->acquireCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
            cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs,
            forUnmarshaling->acquireCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys,
                    forUnmarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys,
                   forUnmarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeouts,
                    forUnmarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts,
                   forUnmarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs,
                    forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
    if (forUnmarshaling->releaseCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->releaseCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->releaseCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
            cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs,
            forUnmarshaling->releaseCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys,
                    forUnmarshaling->releaseCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys,
                   forUnmarshaling->releaseCount * sizeof(const uint64_t));
}

#endif
#ifdef VK_KHR_external_semaphore_capabilities
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
void marshal_VkImportSemaphoreWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
                   sizeof(VkSemaphoreImportFlags));
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkExportSemaphoreWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAttributes) {
        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
                        sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAttributes) {
        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
                       sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkD3D12FenceSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkD3D12FenceSubmitInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pWaitSemaphoreValues) {
        vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues,
                        forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
    }
    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pSignalSemaphoreValues) {
        vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues,
                        forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
    }
}

void unmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkD3D12FenceSubmitInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pWaitSemaphoreValues) {
        vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreValues,
                        forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
        vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues,
                       forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSignalSemaphoreValues) {
        vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreValues,
                        forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
        vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues,
                       forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
    }
}

void marshal_VkSemaphoreGetWin32HandleInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_external_semaphore_fd
void marshal_VkImportSemaphoreFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkImportSemaphoreFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}

void unmarshal_VkImportSemaphoreFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          VkImportSemaphoreFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
                   sizeof(VkSemaphoreImportFlags));
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}

void marshal_VkSemaphoreGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkSemaphoreGetFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

void unmarshal_VkSemaphoreGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkSemaphoreGetFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_push_descriptor
void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
}

#endif
#ifdef VK_KHR_shader_float16_int8
#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
void marshal_VkRectLayerKHR(VulkanStream* vkStream, VkStructureType rootType,
                            const VkRectLayerKHR* forMarshaling) {
    (void)rootType;
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent));
    vkStream->write((uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
}

void unmarshal_VkRectLayerKHR(VulkanStream* vkStream, VkStructureType rootType,
                              VkRectLayerKHR* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->offset));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->extent));
    vkStream->read((uint32_t*)&forUnmarshaling->layer, sizeof(uint32_t));
}

void marshal_VkPresentRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
                                const VkPresentRegionKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pRectangles) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i) {
                marshal_VkRectLayerKHR(vkStream, rootType,
                                       (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
            }
        }
    }
}

void unmarshal_VkPresentRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  VkPresentRegionKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->rectangleCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pRectangles = (const VkRectLayerKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pRectangles) {
        vkStream->alloc((void**)&forUnmarshaling->pRectangles,
                        forUnmarshaling->rectangleCount * sizeof(const VkRectLayerKHR));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i) {
                unmarshal_VkRectLayerKHR(vkStream, rootType,
                                         (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
            }
        }
    }
}

void marshal_VkPresentRegionsKHR(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkPresentRegionsKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pRegions) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
                marshal_VkPresentRegionKHR(
                    vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
            }
        }
    }
}

void unmarshal_VkPresentRegionsKHR(VulkanStream* vkStream, VkStructureType rootType,
                                   VkPresentRegionsKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pRegions = (const VkPresentRegionKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pRegions) {
        vkStream->alloc((void**)&forUnmarshaling->pRegions,
                        forUnmarshaling->swapchainCount * sizeof(const VkPresentRegionKHR));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i) {
                unmarshal_VkPresentRegionKHR(vkStream, rootType,
                                             (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
            }
        }
    }
}

#endif
#ifdef VK_KHR_descriptor_update_template
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
#endif
#ifdef VK_KHR_shared_presentable_image
void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags,
                    sizeof(VkImageUsageFlags));
}

void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags,
                   sizeof(VkImageUsageFlags));
}

#endif
#ifdef VK_KHR_external_fence_capabilities
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
void marshal_VkImportFenceWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkImportFenceWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalFenceHandleTypeFlagBits));
    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkImportFenceWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkImportFenceWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
                                                      (VkFence*)&forUnmarshaling->fence, 1);
    vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalFenceHandleTypeFlagBits));
    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkExportFenceWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkExportFenceWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAttributes) {
        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
                        sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}

void unmarshal_VkExportFenceWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkExportFenceWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAttributes) {
        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
                       sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}

void marshal_VkFenceGetWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkFenceGetWin32HandleInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalFenceHandleTypeFlagBits));
}

void unmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                            VkFenceGetWin32HandleInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
                                                      (VkFence*)&forUnmarshaling->fence, 1);
    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalFenceHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_external_fence_fd
void marshal_VkImportFenceFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkImportFenceFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalFenceHandleTypeFlagBits));
    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}

void unmarshal_VkImportFenceFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      VkImportFenceFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
                                                      (VkFence*)&forUnmarshaling->fence, 1);
    vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalFenceHandleTypeFlagBits));
    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}

void marshal_VkFenceGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkFenceGetFdInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalFenceHandleTypeFlagBits));
}

void unmarshal_VkFenceGetFdInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                   VkFenceGetFdInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
                                                      (VkFence*)&forUnmarshaling->fence, 1);
    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalFenceHandleTypeFlagBits));
}

#endif
#ifdef VK_KHR_performance_query
void marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->performanceCounterQueryPools, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->performanceCounterMultipleQueryPools,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->performanceCounterQueryPools, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->performanceCounterMultipleQueryPools,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
}

void marshal_VkPerformanceCounterKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkPerformanceCounterKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPerformanceCounterUnitKHR*)&forMarshaling->unit,
                    sizeof(VkPerformanceCounterUnitKHR));
    vkStream->write((VkPerformanceCounterScopeKHR*)&forMarshaling->scope,
                    sizeof(VkPerformanceCounterScopeKHR));
    vkStream->write((VkPerformanceCounterStorageKHR*)&forMarshaling->storage,
                    sizeof(VkPerformanceCounterStorageKHR));
    vkStream->write((uint8_t*)forMarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}

void unmarshal_VkPerformanceCounterKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkPerformanceCounterKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPerformanceCounterUnitKHR*)&forUnmarshaling->unit,
                   sizeof(VkPerformanceCounterUnitKHR));
    vkStream->read((VkPerformanceCounterScopeKHR*)&forUnmarshaling->scope,
                   sizeof(VkPerformanceCounterScopeKHR));
    vkStream->read((VkPerformanceCounterStorageKHR*)&forUnmarshaling->storage,
                   sizeof(VkPerformanceCounterStorageKHR));
    vkStream->read((uint8_t*)forUnmarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}

void marshal_VkPerformanceCounterDescriptionKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPerformanceCounterDescriptionKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkPerformanceCounterDescriptionFlagsKHR));
    vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void unmarshal_VkPerformanceCounterDescriptionKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPerformanceCounterDescriptionKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPerformanceCounterDescriptionFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkPerformanceCounterDescriptionFlagsKHR));
    vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}

void marshal_VkQueryPoolPerformanceCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->counterIndexCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pCounterIndices,
                    forMarshaling->counterIndexCount * sizeof(const uint32_t));
}

void unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->counterIndexCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCounterIndices,
                    forUnmarshaling->counterIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pCounterIndices,
                   forUnmarshaling->counterIndexCount * sizeof(const uint32_t));
}

void marshal_VkPerformanceCounterResultKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkPerformanceCounterResultKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((int32_t*)&forMarshaling->int32, sizeof(int32_t));
}

void unmarshal_VkPerformanceCounterResultKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkPerformanceCounterResultKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((int32_t*)&forUnmarshaling->int32, sizeof(int32_t));
}

void marshal_VkAcquireProfilingLockInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkAcquireProfilingLockInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkAcquireProfilingLockFlagsKHR));
    vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
}

void unmarshal_VkAcquireProfilingLockInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkAcquireProfilingLockInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAcquireProfilingLockFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkAcquireProfilingLockFlagsKHR));
    vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
}

void marshal_VkPerformanceQuerySubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPerformanceQuerySubmitInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->counterPassIndex, sizeof(uint32_t));
}

void unmarshal_VkPerformanceQuerySubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkPerformanceQuerySubmitInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->counterPassIndex, sizeof(uint32_t));
}

#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
void marshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(
        &cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
}

void marshal_VkSurfaceCapabilities2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSurfaceCapabilities2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkSurfaceCapabilitiesKHR(
        vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
}

void unmarshal_VkSurfaceCapabilities2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkSurfaceCapabilities2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkSurfaceCapabilitiesKHR(
        vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
}

void marshal_VkSurfaceFormat2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSurfaceFormat2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkSurfaceFormatKHR(vkStream, rootType,
                               (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
}

void unmarshal_VkSurfaceFormat2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSurfaceFormat2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkSurfaceFormatKHR(vkStream, rootType,
                                 (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
}

#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
void marshal_VkDisplayProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkDisplayProperties2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDisplayPropertiesKHR(vkStream, rootType,
                                   (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
}

void unmarshal_VkDisplayProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                       VkDisplayProperties2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDisplayPropertiesKHR(
        vkStream, rootType, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
}

void marshal_VkDisplayPlaneProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkDisplayPlaneProperties2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDisplayPlanePropertiesKHR(
        vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
}

void unmarshal_VkDisplayPlaneProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                            VkDisplayPlaneProperties2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDisplayPlanePropertiesKHR(
        vkStream, rootType,
        (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
}

void marshal_VkDisplayModeProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDisplayModeProperties2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDisplayModePropertiesKHR(
        vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
}

void unmarshal_VkDisplayModeProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDisplayModeProperties2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDisplayModePropertiesKHR(
        vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
}

void marshal_VkDisplayPlaneInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkDisplayPlaneInfo2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_0,
                                                               1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
}

void unmarshal_VkDisplayPlaneInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                      VkDisplayPlaneInfo2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
        &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
}

void marshal_VkDisplayPlaneCapabilities2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkDisplayPlaneCapabilities2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDisplayPlaneCapabilitiesKHR(
        vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
}

void unmarshal_VkDisplayPlaneCapabilities2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                              VkDisplayPlaneCapabilities2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDisplayPlaneCapabilitiesKHR(
        vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
}

#endif
#ifdef VK_KHR_dedicated_allocation
#endif
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
#endif
#ifdef VK_KHR_bind_memory2
#endif
#ifdef VK_KHR_portability_subset
void marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->events, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->imageViewFormatReinterpretation, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->imageViewFormatSwizzle, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->imageView2DOn3DImage, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multisampleArrayImage, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->mutableComparisonSamplers, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->pointPolygons, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->samplerMipLodBias, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->separateStencilMaskRef, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->tessellationIsolines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->tessellationPointMode, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->triangleFans, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vertexAttributeAccessBeyondStride, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->events, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->imageViewFormatReinterpretation, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->imageViewFormatSwizzle, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->imageView2DOn3DImage, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multisampleArrayImage, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->mutableComparisonSamplers, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->pointPolygons, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->samplerMipLodBias, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->separateStencilMaskRef, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampleRateInterpolationFunctions,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->tessellationIsolines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->tessellationPointMode, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->triangleFans, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeAccessBeyondStride,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->minVertexInputBindingStrideAlignment,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->minVertexInputBindingStrideAlignment,
                   sizeof(uint32_t));
}

#endif
#ifdef VK_KHR_maintenance3
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
#endif
#ifdef VK_KHR_8bit_storage
#endif
#ifdef VK_KHR_shader_atomic_int64
#endif
#ifdef VK_KHR_shader_clock
void marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupClock, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderDeviceClock, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupClock, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderDeviceClock, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_video_decode_h265
void marshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH265ProfileInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
                    sizeof(StdVideoH265ProfileIdc));
}

void unmarshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH265ProfileInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
                   sizeof(StdVideoH265ProfileIdc));
}

void marshal_VkVideoDecodeH265CapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH265CapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH265LevelIdc*)&forMarshaling->maxLevelIdc,
                    sizeof(StdVideoH265LevelIdc));
}

void unmarshal_VkVideoDecodeH265CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoDecodeH265CapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH265LevelIdc*)&forUnmarshaling->maxLevelIdc,
                   sizeof(StdVideoH265LevelIdc));
}

void marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH265SessionParametersAddInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->stdVPSCount, sizeof(uint32_t));
    vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pStdVPSs,
                    forMarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
    vkStream->write((const StdVideoH265SequenceParameterSet*)forMarshaling->pStdSPSs,
                    forMarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
    vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pStdPPSs,
                    forMarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
}

void unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoDecodeH265SessionParametersAddInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdVPSCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
                    forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
    vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs,
                   forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
    vkStream->read((StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs,
                   forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
    vkStream->read((StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs,
                   forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
}

void marshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxStdVPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pParametersAddInfo) {
        marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
            vkStream, rootType,
            (const VkVideoDecodeH265SessionParametersAddInfoKHR*)(forMarshaling
                                                                      ->pParametersAddInfo));
    }
}

void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoDecodeH265SessionParametersCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdVPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pParametersAddInfo =
        (const VkVideoDecodeH265SessionParametersAddInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pParametersAddInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
                        sizeof(const VkVideoDecodeH265SessionParametersAddInfoKHR));
        unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
            vkStream, rootType,
            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo));
    }
}

void marshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH265PictureInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
                    sizeof(const StdVideoDecodeH265PictureInfo));
    vkStream->write((uint32_t*)&forMarshaling->sliceSegmentCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pSliceSegmentOffsets,
                    forMarshaling->sliceSegmentCount * sizeof(const uint32_t));
}

void unmarshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH265PictureInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                    sizeof(const StdVideoDecodeH265PictureInfo));
    vkStream->read((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
                   sizeof(const StdVideoDecodeH265PictureInfo));
    vkStream->read((uint32_t*)&forUnmarshaling->sliceSegmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSliceSegmentOffsets,
                    forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pSliceSegmentOffsets,
                   forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
}

void marshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH265DpbSlotInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoDecodeH265ReferenceInfo));
}

void unmarshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoDecodeH265DpbSlotInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoDecodeH265ReferenceInfo));
    vkStream->read((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
                   sizeof(const StdVideoDecodeH265ReferenceInfo));
}

#endif
#ifdef VK_KHR_global_priority
void marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceQueueGlobalPriorityCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkQueueGlobalPriorityKHR*)&forMarshaling->globalPriority,
                    sizeof(VkQueueGlobalPriorityKHR));
}

void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceQueueGlobalPriorityCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkQueueGlobalPriorityKHR*)&forUnmarshaling->globalPriority,
                   sizeof(VkQueueGlobalPriorityKHR));
}

void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->globalPriorityQuery, sizeof(VkBool32));
}

void marshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueueFamilyGlobalPriorityPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
    vkStream->write((VkQueueGlobalPriorityKHR*)forMarshaling->priorities,
                    VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
}

void unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueueFamilyGlobalPriorityPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->priorityCount, sizeof(uint32_t));
    vkStream->read((VkQueueGlobalPriorityKHR*)forUnmarshaling->priorities,
                   VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
}

#endif
#ifdef VK_KHR_driver_properties
#endif
#ifdef VK_KHR_shader_float_controls
#endif
#ifdef VK_KHR_depth_stencil_resolve
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
#endif
#ifdef VK_KHR_vulkan_memory_model
#endif
#ifdef VK_KHR_shader_terminate_invocation
#endif
#ifdef VK_KHR_fragment_shading_rate
void marshal_VkFragmentShadingRateAttachmentInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pFragmentShadingRateAttachment;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pFragmentShadingRateAttachment) {
        marshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment));
    }
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
}

void unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pFragmentShadingRateAttachment =
        (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pFragmentShadingRateAttachment) {
        vkStream->alloc((void**)&forUnmarshaling->pFragmentShadingRateAttachment,
                        sizeof(const VkAttachmentReference2));
        unmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (VkAttachmentReference2*)(forUnmarshaling->pFragmentShadingRateAttachment));
    }
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
}

void marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize));
    vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
                    2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

void unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
    vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps,
                   2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

void marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->attachmentFragmentShadingRate, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->attachmentFragmentShadingRate, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize));
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
                    sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps,
                    sizeof(VkBool32));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentSize));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples,
                    sizeof(uint32_t));
    vkStream->write(
        (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples,
        sizeof(VkSampleCountFlagBits));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithSampleMask, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(
        vkStream, rootType,
        (VkExtent2D*)(&forUnmarshaling->minFragmentShadingRateAttachmentTexelSize));
    unmarshal_VkExtent2D(
        vkStream, rootType,
        (VkExtent2D*)(&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSize));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
        sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateWithMultipleViewports,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateNonTrivialCombinerOps,
                   sizeof(VkBool32));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxFragmentSize));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentShadingRateCoverageSamples,
                   sizeof(uint32_t));
    vkStream->read(
        (VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateRasterizationSamples,
        sizeof(VkSampleCountFlagBits));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithSampleMask,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderSampleMask,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithConservativeRasterization,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithFragmentShaderInterlock,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithCustomSampleLocations,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateStrictMultiplyCombiner,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentShadingRateKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize));
}

void unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
}

#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void marshal_VkSurfaceProtectedCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfaceProtectedCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->supportsProtected, sizeof(VkBool32));
}

void unmarshal_VkSurfaceProtectedCapabilitiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->supportsProtected, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_present_wait
void marshal_VkPhysicalDevicePresentWaitFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->presentWait, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePresentWaitFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->presentWait, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
#endif
#ifdef VK_KHR_buffer_device_address
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineExecutableInfo, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineExecutableInfo, sizeof(VkBool32));
}

void marshal_VkPipelineInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                               const VkPipelineInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkPipelineInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                 VkPipelineInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
}

void marshal_VkPipelineExecutablePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineExecutablePropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderStageFlags*)&forMarshaling->stages, sizeof(VkShaderStageFlags));
    vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
}

void unmarshal_VkPipelineExecutablePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineExecutablePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stages, sizeof(VkShaderStageFlags));
    vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
}

void marshal_VkPipelineExecutableInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkPipelineExecutableInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->executableIndex, sizeof(uint32_t));
}

void unmarshal_VkPipelineExecutableInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkPipelineExecutableInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->executableIndex, sizeof(uint32_t));
}

void marshal_VkPipelineExecutableStatisticValueKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineExecutableStatisticValueKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBool32*)&forMarshaling->b32, sizeof(VkBool32));
}

void unmarshal_VkPipelineExecutableStatisticValueKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineExecutableStatisticValueKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBool32*)&forUnmarshaling->b32, sizeof(VkBool32));
}

void marshal_VkPipelineExecutableStatisticKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineExecutableStatisticKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format,
                    sizeof(VkPipelineExecutableStatisticFormatKHR));
    marshal_VkPipelineExecutableStatisticValueKHR(
        vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value));
}

void unmarshal_VkPipelineExecutableStatisticKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPipelineExecutableStatisticKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((VkPipelineExecutableStatisticFormatKHR*)&forUnmarshaling->format,
                   sizeof(VkPipelineExecutableStatisticFormatKHR));
    unmarshal_VkPipelineExecutableStatisticValueKHR(
        vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forUnmarshaling->value));
}

void marshal_VkPipelineExecutableInternalRepresentationKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineExecutableInternalRepresentationKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((VkBool32*)&forMarshaling->isText, sizeof(VkBool32));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    vkStream->putBe64(cgen_var_0);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pData;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pData) {
        vkStream->write((void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(uint8_t));
    }
}

void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((VkBool32*)&forUnmarshaling->isText, sizeof(VkBool32));
    forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
    // WARNING PTR CHECK
    forUnmarshaling->pData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pData) {
        vkStream->alloc((void**)&forUnmarshaling->pData,
                        forUnmarshaling->dataSize * sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(uint8_t));
    }
}

#endif
#ifdef VK_KHR_map_memory2
void marshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                const VkMemoryMapInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMemoryMapFlags*)&forMarshaling->flags, sizeof(VkMemoryMapFlags));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  VkMemoryMapInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMemoryMapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryMapFlags));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkMemoryUnmapInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMemoryUnmapFlagsKHR*)&forMarshaling->flags, sizeof(VkMemoryUnmapFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    VkMemoryUnmapInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMemoryUnmapFlagsKHR*)&forUnmarshaling->flags, sizeof(VkMemoryUnmapFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}

#endif
#ifdef VK_KHR_shader_integer_dot_product
#endif
#ifdef VK_KHR_pipeline_library
void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkPipelineLibraryCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->libraryCount, sizeof(uint32_t));
    if (forMarshaling->libraryCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->libraryCount * 8);
        vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pLibraries, cgen_var_0,
                                                             forMarshaling->libraryCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->libraryCount * 8);
    }
}

void unmarshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                              VkPipelineLibraryCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->libraryCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pLibraries,
                    forUnmarshaling->libraryCount * sizeof(const VkPipeline));
    if (forUnmarshaling->libraryCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->libraryCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->libraryCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkPipeline(
            cgen_var_0, (VkPipeline*)forUnmarshaling->pLibraries, forUnmarshaling->libraryCount);
    }
}

#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
void marshal_VkPresentIdKHR(VulkanStream* vkStream, VkStructureType rootType,
                            const VkPresentIdKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPresentIds;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pPresentIds) {
        vkStream->write((const uint64_t*)forMarshaling->pPresentIds,
                        forMarshaling->swapchainCount * sizeof(const uint64_t));
    }
}

void unmarshal_VkPresentIdKHR(VulkanStream* vkStream, VkStructureType rootType,
                              VkPresentIdKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pPresentIds = (const uint64_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pPresentIds) {
        vkStream->alloc((void**)&forUnmarshaling->pPresentIds,
                        forUnmarshaling->swapchainCount * sizeof(const uint64_t));
        vkStream->read((uint64_t*)forUnmarshaling->pPresentIds,
                       forUnmarshaling->swapchainCount * sizeof(const uint64_t));
    }
}

void marshal_VkPhysicalDevicePresentIdFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->presentId, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePresentIdFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->presentId, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_video_encode_queue
void marshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkVideoEncodeInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEncodeFlagsKHR));
    vkStream->write((uint32_t*)&forMarshaling->qualityLevel, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->dstBufferOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->dstBufferRange, sizeof(VkDeviceSize));
    marshal_VkVideoPictureResourceInfoKHR(
        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forMarshaling->srcPictureResource));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSetupReferenceSlot;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pSetupReferenceSlot) {
        marshal_VkVideoReferenceSlotInfoKHR(
            vkStream, rootType,
            (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pSetupReferenceSlot));
    }
    vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
            marshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->precedingExternallyEncodedBytes, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    VkVideoEncodeInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoEncodeFlagsKHR));
    vkStream->read((uint32_t*)&forUnmarshaling->qualityLevel, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBufferOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBufferRange, sizeof(VkDeviceSize));
    unmarshal_VkVideoPictureResourceInfoKHR(
        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->srcPictureResource));
    // WARNING PTR CHECK
    forUnmarshaling->pSetupReferenceSlot =
        (const VkVideoReferenceSlotInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSetupReferenceSlot) {
        vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
                        sizeof(const VkVideoReferenceSlotInfoKHR));
        unmarshal_VkVideoReferenceSlotInfoKHR(
            vkStream, rootType,
            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pReferenceSlots,
        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
            unmarshal_VkVideoReferenceSlotInfoKHR(
                vkStream, rootType,
                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->precedingExternallyEncodedBytes, sizeof(uint32_t));
}

void marshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkVideoEncodeCapabilitiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeCapabilityFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoEncodeCapabilityFlagsKHR));
    vkStream->write((VkVideoEncodeRateControlModeFlagsKHR*)&forMarshaling->rateControlModes,
                    sizeof(VkVideoEncodeRateControlModeFlagsKHR));
    vkStream->write((uint32_t*)&forMarshaling->maxRateControlLayers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxQualityLevels, sizeof(uint32_t));
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->inputImageDataFillAlignment));
    vkStream->write((VkVideoEncodeFeedbackFlagsKHR*)&forMarshaling->supportedEncodeFeedbackFlags,
                    sizeof(VkVideoEncodeFeedbackFlagsKHR));
}

void unmarshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                            VkVideoEncodeCapabilitiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeCapabilityFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoEncodeCapabilityFlagsKHR));
    vkStream->read((VkVideoEncodeRateControlModeFlagsKHR*)&forUnmarshaling->rateControlModes,
                   sizeof(VkVideoEncodeRateControlModeFlagsKHR));
    vkStream->read((uint32_t*)&forUnmarshaling->maxRateControlLayers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxQualityLevels, sizeof(uint32_t));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->inputImageDataFillAlignment));
    vkStream->read((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->supportedEncodeFeedbackFlags,
                   sizeof(VkVideoEncodeFeedbackFlagsKHR));
}

void marshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeFeedbackFlagsKHR*)&forMarshaling->encodeFeedbackFlags,
                    sizeof(VkVideoEncodeFeedbackFlagsKHR));
}

void unmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->encodeFeedbackFlags,
                   sizeof(VkVideoEncodeFeedbackFlagsKHR));
}

void marshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkVideoEncodeUsageInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeUsageFlagsKHR*)&forMarshaling->videoUsageHints,
                    sizeof(VkVideoEncodeUsageFlagsKHR));
    vkStream->write((VkVideoEncodeContentFlagsKHR*)&forMarshaling->videoContentHints,
                    sizeof(VkVideoEncodeContentFlagsKHR));
    vkStream->write((VkVideoEncodeTuningModeKHR*)&forMarshaling->tuningMode,
                    sizeof(VkVideoEncodeTuningModeKHR));
}

void unmarshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                         VkVideoEncodeUsageInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints,
                   sizeof(VkVideoEncodeUsageFlagsKHR));
    vkStream->read((VkVideoEncodeContentFlagsKHR*)&forUnmarshaling->videoContentHints,
                   sizeof(VkVideoEncodeContentFlagsKHR));
    vkStream->read((VkVideoEncodeTuningModeKHR*)&forUnmarshaling->tuningMode,
                   sizeof(VkVideoEncodeTuningModeKHR));
}

void marshal_VkVideoEncodeRateControlLayerInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeRateControlLayerInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->averageBitrate, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->maxBitrate, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->frameRateNumerator, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->frameRateDenominator, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->initialVirtualBufferSizeInMs, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeRateControlLayerInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->averageBitrate, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxBitrate, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->frameRateNumerator, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->frameRateDenominator, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->initialVirtualBufferSizeInMs, sizeof(uint32_t));
}

void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoEncodeRateControlInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkVideoEncodeRateControlFlagsKHR));
    vkStream->write((VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
                    sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->layerCount; ++i) {
            marshal_VkVideoEncodeRateControlLayerInfoKHR(
                vkStream, rootType,
                (const VkVideoEncodeRateControlLayerInfoKHR*)(forMarshaling->pLayers + i));
        }
    }
}

void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoEncodeRateControlInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkVideoEncodeRateControlFlagsKHR));
    vkStream->read((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode,
                   sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pLayers,
        forUnmarshaling->layerCount * sizeof(const VkVideoEncodeRateControlLayerInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->layerCount; ++i) {
            unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
                vkStream, rootType,
                (VkVideoEncodeRateControlLayerInfoKHR*)(forUnmarshaling->pLayers + i));
        }
    }
}

#endif
#ifdef VK_KHR_synchronization2
void marshal_VkQueueFamilyCheckpointProperties2NV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueueFamilyCheckpointProperties2NV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->checkpointExecutionStageMask,
                    sizeof(VkPipelineStageFlags2));
}

void unmarshal_VkQueueFamilyCheckpointProperties2NV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueueFamilyCheckpointProperties2NV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->checkpointExecutionStageMask,
                   sizeof(VkPipelineStageFlags2));
}

void marshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkCheckpointData2NV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pCheckpointMarker) {
        vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
    }
}

void unmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
                                   VkCheckpointData2NV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlags2));
    // WARNING PTR CHECK
    forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pCheckpointMarker) {
        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_KHR_fragment_shader_barycentric
void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->triStripVertexOrderIndependentOfProvokingVertex,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->triStripVertexOrderIndependentOfProvokingVertex,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupUniformControlFlow, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupUniformControlFlow, sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout8BitAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout16BitAccess,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_copy_commands2
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
#ifdef VK_KHR_ray_tracing_maintenance1
void marshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayTracingMaintenance1, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect2,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMaintenance1, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect2,
                   sizeof(VkBool32));
}

void marshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkTraceRaysIndirectCommand2KHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->raygenShaderRecordAddress,
                    sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->raygenShaderRecordSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceAddress*)&forMarshaling->missShaderBindingTableAddress,
                    sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->missShaderBindingTableSize,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->missShaderBindingTableStride,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceAddress*)&forMarshaling->hitShaderBindingTableAddress,
                    sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->hitShaderBindingTableSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->hitShaderBindingTableStride,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceAddress*)&forMarshaling->callableShaderBindingTableAddress,
                    sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->callableShaderBindingTableSize,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->callableShaderBindingTableStride,
                    sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
}

void unmarshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
                                              VkTraceRaysIndirectCommand2KHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->raygenShaderRecordAddress,
                   sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->raygenShaderRecordSize, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->missShaderBindingTableAddress,
                   sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableStride,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->hitShaderBindingTableAddress,
                   sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableStride,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->callableShaderBindingTableAddress,
                   sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableStride,
                   sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
}

#endif
#ifdef VK_KHR_portability_enumeration
#endif
#ifdef VK_KHR_maintenance4
#endif
#ifdef VK_KHR_ray_tracing_position_fetch
void marshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayTracingPositionFetch, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPositionFetch, sizeof(VkBool32));
}

#endif
#ifdef VK_ANDROID_native_buffer
void marshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkNativeBufferUsage2ANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
}

void unmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                           VkNativeBufferUsage2ANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint64_t*)&forUnmarshaling->consumer, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->producer, sizeof(uint64_t));
}

void marshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkNativeBufferANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->handle) {
        vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
    }
    vkStream->write((int*)&forMarshaling->stride, sizeof(int));
    vkStream->write((int*)&forMarshaling->format, sizeof(int));
    vkStream->write((int*)&forMarshaling->usage, sizeof(int));
    marshal_VkNativeBufferUsage2ANDROID(vkStream, rootType,
                                        (VkNativeBufferUsage2ANDROID*)(&forMarshaling->usage2));
}

void unmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                     VkNativeBufferANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->handle) {
        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
        vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
    }
    vkStream->read((int*)&forUnmarshaling->stride, sizeof(int));
    vkStream->read((int*)&forUnmarshaling->format, sizeof(int));
    vkStream->read((int*)&forUnmarshaling->usage, sizeof(int));
    unmarshal_VkNativeBufferUsage2ANDROID(vkStream, rootType,
                                          (VkNativeBufferUsage2ANDROID*)(&forUnmarshaling->usage2));
}

void marshal_VkSwapchainImageCreateInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSwapchainImageCreateInfoANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSwapchainImageUsageFlagsANDROID*)&forMarshaling->usage,
                    sizeof(VkSwapchainImageUsageFlagsANDROID));
}

void unmarshal_VkSwapchainImageCreateInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSwapchainImageCreateInfoANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSwapchainImageUsageFlagsANDROID*)&forUnmarshaling->usage,
                   sizeof(VkSwapchainImageUsageFlagsANDROID));
}

void marshal_VkPhysicalDevicePresentationPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentationPropertiesANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->sharedImage, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePresentationPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePresentationPropertiesANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->sharedImage, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_debug_report
void marshal_VkDebugReportCallbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDebugReportCallbackCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnCallback;
    vkStream->putBe64(cgen_var_0);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pUserData) {
        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
    }
}

void unmarshal_VkDebugReportCallbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDebugReportCallbackCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDebugReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugReportFlagsEXT));
    forUnmarshaling->pfnCallback = (PFN_vkDebugReportCallbackEXT)vkStream->getBe64();
    // WARNING PTR CHECK
    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUserData) {
        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_NV_glsl_shader
#endif
#ifdef VK_EXT_depth_range_unrestricted
#endif
#ifdef VK_IMG_filter_cubic
#endif
#ifdef VK_AMD_rasterization_order
void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder,
                    sizeof(VkRasterizationOrderAMD));
}

void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder,
                   sizeof(VkRasterizationOrderAMD));
}

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void marshal_VkDebugMarkerObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkDebugMarkerObjectNameInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
                    sizeof(VkDebugReportObjectTypeEXT));
    vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
    vkStream->putString(forMarshaling->pObjectName);
}

void unmarshal_VkDebugMarkerObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkDebugMarkerObjectNameInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType,
                   sizeof(VkDebugReportObjectTypeEXT));
    vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
}

void marshal_VkDebugMarkerObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDebugMarkerObjectTagInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
                    sizeof(VkDebugReportObjectTypeEXT));
    vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pTag,
                    forMarshaling->tagSize * sizeof(const uint8_t));
}

void unmarshal_VkDebugMarkerObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDebugMarkerObjectTagInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType,
                   sizeof(VkDebugReportObjectTypeEXT));
    vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
    forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pTag,
                    forUnmarshaling->tagSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
}

void marshal_VkDebugMarkerMarkerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDebugMarkerMarkerInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->putString(forMarshaling->pMarkerName);
    vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}

void unmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDebugMarkerMarkerInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pMarkerName);
    vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
}

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void marshal_VkDedicatedAllocationImageCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationImageCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
}

void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
}

void marshal_VkDedicatedAllocationBufferCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
}

void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
}

void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}

void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

#endif
#ifdef VK_EXT_transform_feedback
void marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->transformFeedback, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->geometryStreams, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedback, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->geometryStreams, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize,
                    sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackStreamDataSize,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataSize,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataStride,
                    sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackQueries, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackDraw, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxTransformFeedbackBufferSize,
                   sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackStreamDataSize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataSize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataStride,
                   sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackQueries, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackStreamsLinesTriangles,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackRasterizationStreamSelect,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackDraw, sizeof(VkBool32));
}

void marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
    vkStream->write((uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
}

void unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->rasterizationStream, sizeof(uint32_t));
}

#endif
#ifdef VK_NVX_binary_import
void marshal_VkCuModuleCreateInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkCuModuleCreateInfoNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pData,
                    forMarshaling->dataSize * sizeof(const uint8_t));
}

void unmarshal_VkCuModuleCreateInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                       VkCuModuleCreateInfoNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pData,
                    forUnmarshaling->dataSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pData,
                   forUnmarshaling->dataSize * sizeof(const uint8_t));
}

void marshal_VkCuFunctionCreateInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkCuFunctionCreateInfoNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->module;
    vkStream->putBe64(cgen_var_0);
    vkStream->putString(forMarshaling->pName);
}

void unmarshal_VkCuFunctionCreateInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                         VkCuFunctionCreateInfoNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->module = (VkCuModuleNVX)vkStream->getBe64();
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
}

void marshal_VkCuLaunchInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                               const VkCuLaunchInfoNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->function;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->gridDimX, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->gridDimY, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->gridDimZ, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->blockDimX, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->blockDimY, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->blockDimZ, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sharedMemBytes, sizeof(uint32_t));
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->paramCount;
    vkStream->putBe64(cgen_var_1);
    uint64_t cgen_var_2 = (uint64_t)forMarshaling->extraCount;
    vkStream->putBe64(cgen_var_2);
}

void unmarshal_VkCuLaunchInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                 VkCuLaunchInfoNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->function = (VkCuFunctionNVX)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->gridDimX, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->gridDimY, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->gridDimZ, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->blockDimX, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->blockDimY, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->blockDimZ, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sharedMemBytes, sizeof(uint32_t));
    forUnmarshaling->paramCount = (size_t)vkStream->getBe64();
    forUnmarshaling->extraCount = (size_t)vkStream->getBe64();
}

#endif
#ifdef VK_NVX_image_view_handle
void marshal_VkImageViewHandleInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkImageViewHandleInfoNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}

void unmarshal_VkImageViewHandleInfoNVX(VulkanStream* vkStream, VkStructureType rootType,
                                        VkImageViewHandleInfoNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_1,
                                                        (VkSampler*)&forUnmarshaling->sampler, 1);
}

void marshal_VkImageViewAddressPropertiesNVX(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkImageViewAddressPropertiesNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkImageViewAddressPropertiesNVX(VulkanStream* vkStream, VkStructureType rootType,
                                               VkImageViewAddressPropertiesNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

#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_EXT_video_encode_h264
void marshal_VkVideoEncodeH264CapabilitiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264CapabilitiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
    vkStream->write((uint32_t*)&forMarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxL1ReferenceCount, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->motionVectorsOverPicBoundariesFlag,
                    sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxBytesPerPicDenom, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxBitsPerMbDenom, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->log2MaxMvLengthHorizontal, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->log2MaxMvLengthVertical, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeH264CapabilityFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->motionVectorsOverPicBoundariesFlag,
                   sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBytesPerPicDenom, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBitsPerMbDenom, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->log2MaxMvLengthHorizontal, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->log2MaxMvLengthVertical, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdSPSs;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdSPSs) {
        vkStream->write(
            (const StdVideoH264SequenceParameterSet*)forMarshaling->pStdSPSs,
            forMarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
    }
    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStdPPSs;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pStdPPSs) {
        vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pStdPPSs,
                        forMarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
    }
}

void unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH264SessionParametersAddInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdSPSs =
        (const StdVideoH264SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdSPSs) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pStdSPSs,
            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
        vkStream->read(
            (StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs,
            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdPPSs =
        (const StdVideoH264PictureParameterSet*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdPPSs) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pStdPPSs,
            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
        vkStream->read(
            (StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs,
            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
    }
}

void marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pParametersAddInfo) {
        marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling
                                                                      ->pParametersAddInfo));
    }
}

void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pParametersAddInfo =
        (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pParametersAddInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
                        sizeof(const VkVideoEncodeH264SessionParametersAddInfoEXT));
        unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
            vkStream, rootType,
            (VkVideoEncodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
    }
}

void marshal_VkVideoEncodeH264NaluSliceInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264NaluSliceInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdReferenceFinalLists) {
        vkStream->write(
            (const StdVideoEncodeH264ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
    }
    vkStream->write((const StdVideoEncodeH264SliceHeader*)forMarshaling->pStdSliceHeader,
                    sizeof(const StdVideoEncodeH264SliceHeader));
}

void unmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH264NaluSliceInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->mbCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdReferenceFinalLists =
        (const StdVideoEncodeH264ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdReferenceFinalLists) {
        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
        vkStream->read(
            (StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdSliceHeader,
                    sizeof(const StdVideoEncodeH264SliceHeader));
    vkStream->read((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pStdSliceHeader,
                   sizeof(const StdVideoEncodeH264SliceHeader));
}

void marshal_VkVideoEncodeH264VclFrameInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdReferenceFinalLists) {
        vkStream->write(
            (const StdVideoEncodeH264ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
    }
    vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
            marshal_VkVideoEncodeH264NaluSliceInfoEXT(
                vkStream, rootType,
                (const VkVideoEncodeH264NaluSliceInfoEXT*)(forMarshaling->pNaluSliceEntries + i));
        }
    }
    vkStream->write((const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
                    sizeof(const StdVideoEncodeH264PictureInfo));
}

void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pStdReferenceFinalLists =
        (const StdVideoEncodeH264ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdReferenceFinalLists) {
        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
        vkStream->read(
            (StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pNaluSliceEntries,
        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceInfoEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
            unmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
                vkStream, rootType,
                (VkVideoEncodeH264NaluSliceInfoEXT*)(forUnmarshaling->pNaluSliceEntries + i));
        }
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                    sizeof(const StdVideoEncodeH264PictureInfo));
    vkStream->read((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
                   sizeof(const StdVideoEncodeH264PictureInfo));
}

void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoEncodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoEncodeH264ReferenceInfo));
}

void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoEncodeH264ReferenceInfo));
    vkStream->read((StdVideoEncodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
                   sizeof(const StdVideoEncodeH264ReferenceInfo));
}

void marshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoEncodeH264ProfileInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
                    sizeof(StdVideoH264ProfileIdc));
}

void unmarshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoEncodeH264ProfileInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
                   sizeof(StdVideoH264ProfileIdc));
}

void marshal_VkVideoEncodeH264RateControlInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264RateControlInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->gopFrameCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->idrPeriod, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->consecutiveBFrameCount, sizeof(uint32_t));
    vkStream->write((VkVideoEncodeH264RateControlStructureEXT*)&forMarshaling->rateControlStructure,
                    sizeof(VkVideoEncodeH264RateControlStructureEXT));
    vkStream->write((uint32_t*)&forMarshaling->temporalLayerCount, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH264RateControlInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH264RateControlInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->gopFrameCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->idrPeriod, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, sizeof(uint32_t));
    vkStream->read(
        (VkVideoEncodeH264RateControlStructureEXT*)&forUnmarshaling->rateControlStructure,
        sizeof(VkVideoEncodeH264RateControlStructureEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->temporalLayerCount, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkVideoEncodeH264QpEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((int32_t*)&forMarshaling->qpI, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->qpP, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->qpB, sizeof(int32_t));
}

void unmarshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkVideoEncodeH264QpEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((int32_t*)&forUnmarshaling->qpI, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->qpP, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->qpB, sizeof(int32_t));
}

void marshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkVideoEncodeH264FrameSizeEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->frameISize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->framePSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->frameBSize, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoEncodeH264FrameSizeEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->frameISize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->framePSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->frameBSize, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH264RateControlLayerInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264RateControlLayerInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->temporalLayerId, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->useInitialRcQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->initialRcQp));
    vkStream->write((VkBool32*)&forMarshaling->useMinQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->minQp));
    vkStream->write((VkBool32*)&forMarshaling->useMaxQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->maxQp));
    vkStream->write((VkBool32*)&forMarshaling->useMaxFrameSize, sizeof(VkBool32));
    marshal_VkVideoEncodeH264FrameSizeEXT(
        vkStream, rootType, (VkVideoEncodeH264FrameSizeEXT*)(&forMarshaling->maxFrameSize));
}

void unmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH264RateControlLayerInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->temporalLayerId, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->useInitialRcQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->initialRcQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMinQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->minQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMaxQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->maxQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMaxFrameSize, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH264FrameSizeEXT(
        vkStream, rootType, (VkVideoEncodeH264FrameSizeEXT*)(&forUnmarshaling->maxFrameSize));
}

#endif
#ifdef VK_EXT_video_encode_h265
void marshal_VkVideoEncodeH265CapabilitiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265CapabilitiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
    vkStream->write((VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
                    sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
    vkStream->write(
        (VkVideoEncodeH265TransformBlockSizeFlagsEXT*)&forMarshaling->transformBlockSizes,
        sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT));
    vkStream->write((uint32_t*)&forMarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxL1ReferenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSubLayersCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minLog2MinLumaCodingBlockSizeMinus3,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxLog2MinLumaCodingBlockSizeMinus3,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minLog2MinLumaTransformBlockSizeMinus2,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxLog2MinLumaTransformBlockSizeMinus2,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minMaxTransformHierarchyDepthInter,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMaxTransformHierarchyDepthInter,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minMaxTransformHierarchyDepthIntra,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMaxTransformHierarchyDepthIntra,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDiffCuQpDeltaDepth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minMaxNumMergeCand, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMaxNumMergeCand, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
    vkStream->read((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes,
                   sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
    vkStream->read(
        (VkVideoEncodeH265TransformBlockSizeFlagsEXT*)&forUnmarshaling->transformBlockSizes,
        sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSubLayersCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minLog2MinLumaCodingBlockSizeMinus3,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxLog2MinLumaCodingBlockSizeMinus3,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minLog2MinLumaTransformBlockSizeMinus2,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxLog2MinLumaTransformBlockSizeMinus2,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthInter,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthInter,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthIntra,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthIntra,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDiffCuQpDeltaDepth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minMaxNumMergeCand, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxNumMergeCand, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->stdVPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdVPSs;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdVPSs) {
        vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pStdVPSs,
                        forMarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
    }
    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStdSPSs;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pStdSPSs) {
        vkStream->write(
            (const StdVideoH265SequenceParameterSet*)forMarshaling->pStdSPSs,
            forMarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
    }
    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pStdPPSs;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pStdPPSs) {
        vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pStdPPSs,
                        forMarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
    }
}

void unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH265SessionParametersAddInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdVPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdVPSs =
        (const StdVideoH265VideoParameterSet*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdVPSs) {
        vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
                        forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
        vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs,
                       forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdSPSs =
        (const StdVideoH265SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdSPSs) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pStdSPSs,
            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
        vkStream->read(
            (StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs,
            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdPPSs =
        (const StdVideoH265PictureParameterSet*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdPPSs) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pStdPPSs,
            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
        vkStream->read(
            (StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs,
            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
    }
}

void marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxStdVPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pParametersAddInfo) {
        marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling
                                                                      ->pParametersAddInfo));
    }
}

void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdVPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pParametersAddInfo =
        (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pParametersAddInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
                        sizeof(const VkVideoEncodeH265SessionParametersAddInfoEXT));
        unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
            vkStream, rootType,
            (VkVideoEncodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
    }
}

void marshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->ctbCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdReferenceFinalLists) {
        vkStream->write(
            (const StdVideoEncodeH265ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
    }
    vkStream->write(
        (const StdVideoEncodeH265SliceSegmentHeader*)forMarshaling->pStdSliceSegmentHeader,
        sizeof(const StdVideoEncodeH265SliceSegmentHeader));
}

void unmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH265NaluSliceSegmentInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->ctbCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pStdReferenceFinalLists =
        (const StdVideoEncodeH265ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdReferenceFinalLists) {
        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
        vkStream->read(
            (StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdSliceSegmentHeader,
                    sizeof(const StdVideoEncodeH265SliceSegmentHeader));
    vkStream->read((StdVideoEncodeH265SliceSegmentHeader*)forUnmarshaling->pStdSliceSegmentHeader,
                   sizeof(const StdVideoEncodeH265SliceSegmentHeader));
}

void marshal_VkVideoEncodeH265VclFrameInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pStdReferenceFinalLists) {
        vkStream->write(
            (const StdVideoEncodeH265ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
    }
    vkStream->write((uint32_t*)&forMarshaling->naluSliceSegmentEntryCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceSegmentEntryCount; ++i) {
            marshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                vkStream, rootType,
                (const VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(forMarshaling
                                                                      ->pNaluSliceSegmentEntries +
                                                                  i));
        }
    }
    vkStream->write((const StdVideoEncodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
                    sizeof(const StdVideoEncodeH265PictureInfo));
}

void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pStdReferenceFinalLists =
        (const StdVideoEncodeH265ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pStdReferenceFinalLists) {
        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
        vkStream->read(
            (StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceSegmentEntryCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pNaluSliceSegmentEntries,
                    forUnmarshaling->naluSliceSegmentEntryCount *
                        sizeof(const VkVideoEncodeH265NaluSliceSegmentInfoEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceSegmentEntryCount; ++i) {
            unmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                vkStream, rootType,
                (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(forUnmarshaling
                                                                ->pNaluSliceSegmentEntries +
                                                            i));
        }
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                    sizeof(const StdVideoEncodeH265PictureInfo));
    vkStream->read((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
                   sizeof(const StdVideoEncodeH265PictureInfo));
}

void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoEncodeH265ReferenceInfo));
}

void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
                    sizeof(const StdVideoEncodeH265ReferenceInfo));
    vkStream->read((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
                   sizeof(const StdVideoEncodeH265ReferenceInfo));
}

void marshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkVideoEncodeH265ProfileInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
                    sizeof(StdVideoH265ProfileIdc));
}

void unmarshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoEncodeH265ProfileInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
                   sizeof(StdVideoH265ProfileIdc));
}

void marshal_VkVideoEncodeH265RateControlInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265RateControlInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->gopFrameCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->idrPeriod, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->consecutiveBFrameCount, sizeof(uint32_t));
    vkStream->write((VkVideoEncodeH265RateControlStructureEXT*)&forMarshaling->rateControlStructure,
                    sizeof(VkVideoEncodeH265RateControlStructureEXT));
    vkStream->write((uint32_t*)&forMarshaling->subLayerCount, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH265RateControlInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH265RateControlInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->gopFrameCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->idrPeriod, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, sizeof(uint32_t));
    vkStream->read(
        (VkVideoEncodeH265RateControlStructureEXT*)&forUnmarshaling->rateControlStructure,
        sizeof(VkVideoEncodeH265RateControlStructureEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->subLayerCount, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkVideoEncodeH265QpEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((int32_t*)&forMarshaling->qpI, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->qpP, sizeof(int32_t));
    vkStream->write((int32_t*)&forMarshaling->qpB, sizeof(int32_t));
}

void unmarshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkVideoEncodeH265QpEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((int32_t*)&forUnmarshaling->qpI, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->qpP, sizeof(int32_t));
    vkStream->read((int32_t*)&forUnmarshaling->qpB, sizeof(int32_t));
}

void marshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkVideoEncodeH265FrameSizeEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->frameISize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->framePSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->frameBSize, sizeof(uint32_t));
}

void unmarshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoEncodeH265FrameSizeEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->frameISize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->framePSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->frameBSize, sizeof(uint32_t));
}

void marshal_VkVideoEncodeH265RateControlLayerInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265RateControlLayerInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->temporalId, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->useInitialRcQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->initialRcQp));
    vkStream->write((VkBool32*)&forMarshaling->useMinQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->minQp));
    vkStream->write((VkBool32*)&forMarshaling->useMaxQp, sizeof(VkBool32));
    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->maxQp));
    vkStream->write((VkBool32*)&forMarshaling->useMaxFrameSize, sizeof(VkBool32));
    marshal_VkVideoEncodeH265FrameSizeEXT(
        vkStream, rootType, (VkVideoEncodeH265FrameSizeEXT*)(&forMarshaling->maxFrameSize));
}

void unmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVideoEncodeH265RateControlLayerInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->temporalId, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->useInitialRcQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->initialRcQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMinQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->minQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMaxQp, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->maxQp));
    vkStream->read((VkBool32*)&forUnmarshaling->useMaxFrameSize, sizeof(VkBool32));
    unmarshal_VkVideoEncodeH265FrameSizeEXT(
        vkStream, rootType, (VkVideoEncodeH265FrameSizeEXT*)(&forUnmarshaling->maxFrameSize));
}

#endif
#ifdef VK_AMD_texture_gather_bias_lod
void marshal_VkTextureLODGatherFormatPropertiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkTextureLODGatherFormatPropertiesAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
}

void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
}

#endif
#ifdef VK_AMD_shader_info
void marshal_VkShaderResourceUsageAMD(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkShaderResourceUsageAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
    vkStream->putBe64(cgen_var_1);
}

void unmarshal_VkShaderResourceUsageAMD(VulkanStream* vkStream, VkStructureType rootType,
                                        VkShaderResourceUsageAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->numUsedVgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->numUsedSgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
    forUnmarshaling->ldsUsageSizeInBytes = (size_t)vkStream->getBe64();
    forUnmarshaling->scratchMemUsageInBytes = (size_t)vkStream->getBe64();
}

void marshal_VkShaderStatisticsInfoAMD(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkShaderStatisticsInfoAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask,
                    sizeof(VkShaderStageFlags));
    marshal_VkShaderResourceUsageAMD(vkStream, rootType,
                                     (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage));
    vkStream->write((uint32_t*)&forMarshaling->numPhysicalVgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->numPhysicalSgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->numAvailableVgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->numAvailableSgprs, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
}

void unmarshal_VkShaderStatisticsInfoAMD(VulkanStream* vkStream, VkStructureType rootType,
                                         VkShaderStatisticsInfoAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask,
                   sizeof(VkShaderStageFlags));
    unmarshal_VkShaderResourceUsageAMD(
        vkStream, rootType, (VkShaderResourceUsageAMD*)(&forUnmarshaling->resourceUsage));
    vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalVgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalSgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->numAvailableVgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->numAvailableSgprs, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
}

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void marshal_VkStreamDescriptorSurfaceCreateInfoGGP(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags,
                    sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
    vkStream->write((GgpStreamDescriptor*)&forMarshaling->streamDescriptor,
                    sizeof(GgpStreamDescriptor));
}

void unmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
    VulkanStream* vkStream, VkStructureType rootType,
    VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forUnmarshaling->flags,
                   sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
    vkStream->read((GgpStreamDescriptor*)&forUnmarshaling->streamDescriptor,
                   sizeof(GgpStreamDescriptor));
}

#endif
#ifdef VK_NV_corner_sampled_image
void marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->cornerSampledImage, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->cornerSampledImage, sizeof(VkBool32));
}

#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void marshal_VkExternalImageFormatPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExternalImageFormatPropertiesNV* forMarshaling) {
    (void)rootType;
    marshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
    vkStream->write((VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures,
                    sizeof(VkExternalMemoryFeatureFlagsNV));
    vkStream->write(
        (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes,
        sizeof(VkExternalMemoryHandleTypeFlagsNV));
    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

void unmarshal_VkExternalImageFormatPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkExternalImageFormatPropertiesNV* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
    vkStream->read((VkExternalMemoryFeatureFlagsNV*)&forUnmarshaling->externalMemoryFeatures,
                   sizeof(VkExternalMemoryFeatureFlagsNV));
    vkStream->read(
        (VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->exportFromImportedHandleTypes,
        sizeof(VkExternalMemoryHandleTypeFlagsNV));
    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->compatibleHandleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

#endif
#ifdef VK_NV_external_memory
void marshal_VkExternalMemoryImageCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExternalMemoryImageCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

void unmarshal_VkExternalMemoryImageCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkExternalMemoryImageCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

void marshal_VkExportMemoryAllocateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkExportMemoryAllocateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
                    sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

void unmarshal_VkExportMemoryAllocateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                            VkExportMemoryAllocateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes,
                   sizeof(VkExternalMemoryHandleTypeFlagsNV));
}

#endif
#ifdef VK_NV_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkImportMemoryWin32HandleInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagsNV));
    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
}

void unmarshal_VkImportMemoryWin32HandleInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                               VkImportMemoryWin32HandleInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagsNV));
    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
}

void marshal_VkExportMemoryWin32HandleInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkExportMemoryWin32HandleInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAttributes) {
        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
                        sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
}

void unmarshal_VkExportMemoryWin32HandleInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                               VkExportMemoryWin32HandleInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAttributes) {
        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
                       sizeof(const SECURITY_ATTRIBUTES));
    }
    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
}

#endif
#ifdef VK_NV_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
    if (forMarshaling->acquireCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->acquireCount * 8);
        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
            forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->acquireCount * 8);
    }
    vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys,
                    forMarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds,
                    forMarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
    if (forMarshaling->releaseCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forMarshaling->releaseCount * 8);
        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
            forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
        vkStream->write((uint64_t*)cgen_var_1, forMarshaling->releaseCount * 8);
    }
    vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys,
                    forMarshaling->releaseCount * sizeof(const uint64_t));
}

void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs,
                    forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
    if (forUnmarshaling->acquireCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->acquireCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->acquireCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
            cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs,
            forUnmarshaling->acquireCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys,
                    forUnmarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys,
                   forUnmarshaling->acquireCount * sizeof(const uint64_t));
    vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeoutMilliseconds,
                    forUnmarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds,
                   forUnmarshaling->acquireCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs,
                    forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
    if (forUnmarshaling->releaseCount) {
        uint64_t* cgen_var_1;
        vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->releaseCount * 8);
        vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->releaseCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
            cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs,
            forUnmarshaling->releaseCount);
    }
    vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys,
                    forUnmarshaling->releaseCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys,
                   forUnmarshaling->releaseCount * sizeof(const uint64_t));
}

#endif
#ifdef VK_EXT_validation_flags
void marshal_VkValidationFlagsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkValidationFlagsEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->disabledValidationCheckCount, sizeof(uint32_t));
    vkStream->write(
        (const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks,
        forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}

void unmarshal_VkValidationFlagsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    VkValidationFlagsEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationCheckCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pDisabledValidationChecks,
        forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
    vkStream->read(
        (VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks,
        forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}

#endif
#ifdef VK_NN_vi_surface
void marshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkViSurfaceCreateInfoNN* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags,
                    sizeof(VkViSurfaceCreateFlagsNN));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->window) {
        vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
    }
}

void unmarshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructureType rootType,
                                       VkViSurfaceCreateInfoNN* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags,
                   sizeof(VkViSurfaceCreateFlagsNN));
    // WARNING PTR CHECK
    forUnmarshaling->window = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->window) {
        vkStream->alloc((void**)&forUnmarshaling->window, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->window, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
#ifdef VK_EXT_astc_decode_mode
void marshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkImageViewASTCDecodeModeEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
}

void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            VkImageViewASTCDecodeModeEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->decodeMode, sizeof(VkFormat));
}

void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_pipeline_robustness
void marshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineRobustnessFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineRobustness, sizeof(VkBool32));
}

void marshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessStorageBuffers,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessUniformBuffers,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessVertexInputs,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write((VkPipelineRobustnessImageBehaviorEXT*)&forMarshaling->defaultRobustnessImages,
                    sizeof(VkPipelineRobustnessImageBehaviorEXT));
}

void unmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineRobustnessPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessStorageBuffers,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessUniformBuffers,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read(
        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessVertexInputs,
        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->defaultRobustnessImages,
                   sizeof(VkPipelineRobustnessImageBehaviorEXT));
}

void marshal_VkPipelineRobustnessCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRobustnessCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->storageBuffers,
                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->uniformBuffers,
                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->vertexInputs,
                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->write((VkPipelineRobustnessImageBehaviorEXT*)&forMarshaling->images,
                    sizeof(VkPipelineRobustnessImageBehaviorEXT));
}

void unmarshal_VkPipelineRobustnessCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRobustnessCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->storageBuffers,
                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->uniformBuffers,
                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->vertexInputs,
                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
    vkStream->read((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->images,
                   sizeof(VkPipelineRobustnessImageBehaviorEXT));
}

#endif
#ifdef VK_EXT_conditional_rendering
void marshal_VkConditionalRenderingBeginInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkConditionalRenderingBeginInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkConditionalRenderingFlagsEXT));
}

void unmarshal_VkConditionalRenderingBeginInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkConditionalRenderingBeginInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkConditionalRenderingFlagsEXT));
}

void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->conditionalRendering, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->inheritedConditionalRendering, sizeof(VkBool32));
}

void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
}

void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->conditionalRenderingEnable, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_clip_space_w_scaling
void marshal_VkViewportWScalingNV(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkViewportWScalingNV* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->xcoeff, sizeof(float));
    vkStream->write((float*)&forMarshaling->ycoeff, sizeof(float));
}

void unmarshal_VkViewportWScalingNV(VulkanStream* vkStream, VkStructureType rootType,
                                    VkViewportWScalingNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->xcoeff, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->ycoeff, sizeof(float));
}

void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pViewportWScalings) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
                marshal_VkViewportWScalingNV(
                    vkStream, rootType,
                    (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
            }
        }
    }
}

void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->viewportWScalingEnable, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pViewportWScalings =
        (const VkViewportWScalingNV*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pViewportWScalings) {
        vkStream->alloc((void**)&forUnmarshaling->pViewportWScalings,
                        forUnmarshaling->viewportCount * sizeof(const VkViewportWScalingNV));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
                unmarshal_VkViewportWScalingNV(
                    vkStream, rootType,
                    (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
void marshal_VkSurfaceCapabilities2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSurfaceCapabilities2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent));
    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
                    sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
                    sizeof(VkCompositeAlphaFlagsKHR));
    vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
                    sizeof(VkImageUsageFlags));
    vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters,
                    sizeof(VkSurfaceCounterFlagsEXT));
}

void unmarshal_VkSurfaceCapabilities2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                         VkSurfaceCapabilities2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->currentExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
                   sizeof(VkSurfaceTransformFlagsKHR));
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
    vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha,
                   sizeof(VkCompositeAlphaFlagsKHR));
    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags,
                   sizeof(VkImageUsageFlags));
    vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->supportedSurfaceCounters,
                   sizeof(VkSurfaceCounterFlagsEXT));
}

#endif
#ifdef VK_EXT_display_control
void marshal_VkDisplayPowerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkDisplayPowerInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState,
                    sizeof(VkDisplayPowerStateEXT));
}

void unmarshal_VkDisplayPowerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     VkDisplayPowerInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState,
                   sizeof(VkDisplayPowerStateEXT));
}

void marshal_VkDeviceEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkDeviceEventInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent,
                    sizeof(VkDeviceEventTypeEXT));
}

void unmarshal_VkDeviceEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    VkDeviceEventInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent,
                   sizeof(VkDeviceEventTypeEXT));
}

void marshal_VkDisplayEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkDisplayEventInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent,
                    sizeof(VkDisplayEventTypeEXT));
}

void unmarshal_VkDisplayEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     VkDisplayEventInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent,
                   sizeof(VkDisplayEventTypeEXT));
}

void marshal_VkSwapchainCounterCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkSwapchainCounterCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters,
                    sizeof(VkSurfaceCounterFlagsEXT));
}

void unmarshal_VkSwapchainCounterCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkSwapchainCounterCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters,
                   sizeof(VkSurfaceCounterFlagsEXT));
}

#endif
#ifdef VK_GOOGLE_display_timing
void marshal_VkRefreshCycleDurationGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkRefreshCycleDurationGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
}

void unmarshal_VkRefreshCycleDurationGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                            VkRefreshCycleDurationGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint64_t*)&forUnmarshaling->refreshDuration, sizeof(uint64_t));
}

void marshal_VkPastPresentationTimingGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkPastPresentationTimingGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
    vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->actualPresentTime, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->earliestPresentTime, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->presentMargin, sizeof(uint64_t));
}

void unmarshal_VkPastPresentationTimingGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                              VkPastPresentationTimingGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
    vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->actualPresentTime, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->earliestPresentTime, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->presentMargin, sizeof(uint64_t));
}

void marshal_VkPresentTimeGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkPresentTimeGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
    vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
}

void unmarshal_VkPresentTimeGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                   VkPresentTimeGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
    vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
}

void marshal_VkPresentTimesInfoGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkPresentTimesInfoGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pTimes) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
                marshal_VkPresentTimeGOOGLE(
                    vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
            }
        }
    }
}

void unmarshal_VkPresentTimesInfoGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                        VkPresentTimesInfoGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pTimes = (const VkPresentTimeGOOGLE*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pTimes) {
        vkStream->alloc((void**)&forUnmarshaling->pTimes,
                        forUnmarshaling->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i) {
                unmarshal_VkPresentTimeGOOGLE(vkStream, rootType,
                                              (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
            }
        }
    }
}

#endif
#ifdef VK_NV_sample_mask_override_coverage
#endif
#ifdef VK_NV_geometry_shader_passthrough
#endif
#ifdef VK_NV_viewport_array2
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->perViewPositionAllComponents, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_viewport_swizzle
void marshal_VkViewportSwizzleNV(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkViewportSwizzleNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->x,
                    sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->y,
                    sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->z,
                    sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->w,
                    sizeof(VkViewportCoordinateSwizzleNV));
}

void unmarshal_VkViewportSwizzleNV(VulkanStream* vkStream, VkStructureType rootType,
                                   VkViewportSwizzleNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->x,
                   sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->y,
                   sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->z,
                   sizeof(VkViewportCoordinateSwizzleNV));
    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->w,
                   sizeof(VkViewportCoordinateSwizzleNV));
}

void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags,
                    sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
            marshal_VkViewportSwizzleNV(
                vkStream, rootType,
                (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
        }
    }
}

void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles,
                    forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
            unmarshal_VkViewportSwizzleNV(
                vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
        }
    }
}

#endif
#ifdef VK_EXT_discard_rectangles
void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxDiscardRectangles, sizeof(uint32_t));
}

void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
    vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode,
                    sizeof(VkDiscardRectangleModeEXT));
    vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pDiscardRectangles) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i) {
                marshal_VkRect2D(vkStream, rootType,
                                 (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
            }
        }
    }
}

void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
    vkStream->read((VkDiscardRectangleModeEXT*)&forUnmarshaling->discardRectangleMode,
                   sizeof(VkDiscardRectangleModeEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->discardRectangleCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pDiscardRectangles = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDiscardRectangles) {
        vkStream->alloc((void**)&forUnmarshaling->pDiscardRectangles,
                        forUnmarshaling->discardRectangleCount * sizeof(const VkRect2D));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i) {
                unmarshal_VkRect2D(vkStream, rootType,
                                   (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_conservative_rasterization
void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
    vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity,
                    sizeof(float));
    vkStream->write((VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->conservativePointAndLineRasterization,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((float*)&forUnmarshaling->primitiveOverestimationSize, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSizeGranularity,
                   sizeof(float));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveUnderestimation, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->conservativePointAndLineRasterization,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->degenerateLinesRasterized, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fullyCoveredFragmentShaderInputVariable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->conservativeRasterizationPostDepthCoverage,
                   sizeof(VkBool32));
}

void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
    vkStream->write(
        (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode,
        sizeof(VkConservativeRasterizationModeEXT));
    vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
}

void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
    vkStream->read(
        (VkConservativeRasterizationModeEXT*)&forUnmarshaling->conservativeRasterizationMode,
        sizeof(VkConservativeRasterizationModeEXT));
    vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSize, sizeof(float));
}

#endif
#ifdef VK_EXT_depth_clip_enable
void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
}

void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
    vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
}

void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
    vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void marshal_VkXYColorEXT(VulkanStream* vkStream, VkStructureType rootType,
                          const VkXYColorEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->x, sizeof(float));
    vkStream->write((float*)&forMarshaling->y, sizeof(float));
}

void unmarshal_VkXYColorEXT(VulkanStream* vkStream, VkStructureType rootType,
                            VkXYColorEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
}

void marshal_VkHdrMetadataEXT(VulkanStream* vkStream, VkStructureType rootType,
                              const VkHdrMetadataEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed));
    marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen));
    marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue));
    marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->whitePoint));
    vkStream->write((float*)&forMarshaling->maxLuminance, sizeof(float));
    vkStream->write((float*)&forMarshaling->minLuminance, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxContentLightLevel, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxFrameAverageLightLevel, sizeof(float));
}

void unmarshal_VkHdrMetadataEXT(VulkanStream* vkStream, VkStructureType rootType,
                                VkHdrMetadataEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkXYColorEXT(vkStream, rootType,
                           (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryRed));
    unmarshal_VkXYColorEXT(vkStream, rootType,
                           (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryGreen));
    unmarshal_VkXYColorEXT(vkStream, rootType,
                           (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryBlue));
    unmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forUnmarshaling->whitePoint));
    vkStream->read((float*)&forUnmarshaling->maxLuminance, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->minLuminance, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxContentLightLevel, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxFrameAverageLightLevel, sizeof(float));
}

#endif
#ifdef VK_MVK_ios_surface
void marshal_VkIOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkIOSSurfaceCreateInfoMVK* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
                    sizeof(VkIOSSurfaceCreateFlagsMVK));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pView) {
        vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
    }
}

void unmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureType rootType,
                                         VkIOSSurfaceCreateInfoMVK* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags,
                   sizeof(VkIOSSurfaceCreateFlagsMVK));
    // WARNING PTR CHECK
    forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pView) {
        vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
        vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
    }
}

#endif
#ifdef VK_MVK_macos_surface
void marshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkMacOSSurfaceCreateInfoMVK* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
                    sizeof(VkMacOSSurfaceCreateFlagsMVK));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pView) {
        vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
    }
}

void unmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureType rootType,
                                           VkMacOSSurfaceCreateInfoMVK* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags,
                   sizeof(VkMacOSSurfaceCreateFlagsMVK));
    // WARNING PTR CHECK
    forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pView) {
        vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
        vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
    }
}

#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void marshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkDebugUtilsLabelEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->putString(forMarshaling->pLabelName);
    vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}

void unmarshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    VkDebugUtilsLabelEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
    vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
}

void marshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDebugUtilsObjectNameInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
    vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
        vkStream->putBe64(cgen_var_0);
        if (forMarshaling->pObjectName) {
            vkStream->putString(forMarshaling->pObjectName);
        }
    } else {
        vkStream->putString(forMarshaling->pObjectName);
    }
}

void unmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDebugUtilsObjectNameInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
    vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        forUnmarshaling->pObjectName = (const char*)(uintptr_t)vkStream->getBe64();
        if (forUnmarshaling->pObjectName) {
            vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
        }
    } else {
        vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
    }
}

void marshal_VkDebugUtilsMessengerCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
        vkStream->putBe64(cgen_var_0);
        if (forMarshaling->pMessageIdName) {
            vkStream->putString(forMarshaling->pMessageIdName);
        }
    } else {
        vkStream->putString(forMarshaling->pMessageIdName);
    }
    vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
    vkStream->putString(forMarshaling->pMessage);
    vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
            marshal_VkDebugUtilsLabelEXT(
                vkStream, rootType, (const VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
            marshal_VkDebugUtilsLabelEXT(
                vkStream, rootType,
                (const VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
            marshal_VkDebugUtilsObjectNameInfoEXT(
                vkStream, rootType,
                (const VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
        }
    }
}

void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        forUnmarshaling->pMessageIdName = (const char*)(uintptr_t)vkStream->getBe64();
        if (forUnmarshaling->pMessageIdName) {
            vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
        }
    } else {
        vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
    }
    vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
    vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
    vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
                    forUnmarshaling->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
            unmarshal_VkDebugUtilsLabelEXT(
                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->cmdBufLabelCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
                    forUnmarshaling->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
            unmarshal_VkDebugUtilsLabelEXT(
                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pObjects,
                    forUnmarshaling->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
            unmarshal_VkDebugUtilsObjectNameInfoEXT(
                vkStream, rootType,
                (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
        }
    }
}

void marshal_VkDebugUtilsMessengerCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
    vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity,
                    sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
    vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType,
                    sizeof(VkDebugUtilsMessageTypeFlagsEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
    vkStream->putBe64(cgen_var_0);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pUserData) {
        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
    }
}

void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
    vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity,
                   sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
    vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType,
                   sizeof(VkDebugUtilsMessageTypeFlagsEXT));
    forUnmarshaling->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)vkStream->getBe64();
    // WARNING PTR CHECK
    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUserData) {
        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
    }
}

void marshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkDebugUtilsObjectTagInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
    vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pTag,
                    forMarshaling->tagSize * sizeof(const uint8_t));
}

void unmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            VkDebugUtilsObjectTagInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
    vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
    forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pTag,
                    forUnmarshaling->tagSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
}

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void marshal_VkAndroidHardwareBufferUsageANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAndroidHardwareBufferUsageANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
}

void unmarshal_VkAndroidHardwareBufferUsageANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAndroidHardwareBufferUsageANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
}

void marshal_VkAndroidHardwareBufferPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
                    sizeof(VkFormatFeatureFlags));
    marshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
                    sizeof(VkSamplerYcbcrModelConversion));
    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
                    sizeof(VkSamplerYcbcrRange));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
                    sizeof(VkChromaLocation));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
                    sizeof(VkChromaLocation));
}

void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures,
                   sizeof(VkFormatFeatureFlags));
    unmarshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
                   sizeof(VkSamplerYcbcrModelConversion));
    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
                   sizeof(VkSamplerYcbcrRange));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
                   sizeof(VkChromaLocation));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
                   sizeof(VkChromaLocation));
}

void marshal_VkImportAndroidHardwareBufferInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
}

void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->buffer, sizeof(AHardwareBuffer));
    vkStream->read((AHardwareBuffer*)forUnmarshaling->buffer, sizeof(AHardwareBuffer));
}

void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}

void marshal_VkExternalFormatANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkExternalFormatANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
}

void unmarshal_VkExternalFormatANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                       VkExternalFormatANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
}

void marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->formatFeatures,
                    sizeof(VkFormatFeatureFlags2));
    marshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
                    sizeof(VkSamplerYcbcrModelConversion));
    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
                    sizeof(VkSamplerYcbcrRange));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
                    sizeof(VkChromaLocation));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
                    sizeof(VkChromaLocation));
}

void unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAndroidHardwareBufferFormatProperties2ANDROID* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->formatFeatures,
                   sizeof(VkFormatFeatureFlags2));
    unmarshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
                   sizeof(VkSamplerYcbcrModelConversion));
    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
                   sizeof(VkSamplerYcbcrRange));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
                   sizeof(VkChromaLocation));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
                   sizeof(VkChromaLocation));
}

#endif
#ifdef VK_EXT_sampler_filter_minmax
#endif
#ifdef VK_AMD_gpu_shader_int16
#endif
#ifdef VK_AMD_mixed_attachment_samples
#endif
#ifdef VK_AMD_shader_fragment_mask
#endif
#ifdef VK_EXT_inline_uniform_block
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
void marshal_VkSampleLocationEXT(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkSampleLocationEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->x, sizeof(float));
    vkStream->write((float*)&forMarshaling->y, sizeof(float));
}

void unmarshal_VkSampleLocationEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   VkSampleLocationEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
}

void marshal_VkSampleLocationsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkSampleLocationsInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel,
                    sizeof(VkSampleCountFlagBits));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize));
    vkStream->write((uint32_t*)&forMarshaling->sampleLocationsCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i) {
            marshal_VkSampleLocationEXT(
                vkStream, rootType,
                (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
        }
    }
}

void unmarshal_VkSampleLocationsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        VkSampleLocationsInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->sampleLocationsPerPixel,
                   sizeof(VkSampleCountFlagBits));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
    vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationsCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSampleLocations,
                    forUnmarshaling->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationsCount; ++i) {
            unmarshal_VkSampleLocationEXT(
                vkStream, rootType, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
        }
    }
}

void marshal_VkAttachmentSampleLocationsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkAttachmentSampleLocationsEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
    marshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}

void unmarshal_VkAttachmentSampleLocationsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkAttachmentSampleLocationsEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentIndex, sizeof(uint32_t));
    unmarshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}

void marshal_VkSubpassSampleLocationsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkSubpassSampleLocationsEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
    marshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}

void unmarshal_VkSubpassSampleLocationsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkSubpassSampleLocationsEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->subpassIndex, sizeof(uint32_t));
    unmarshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}

void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount,
                    sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount;
             ++i) {
            marshal_VkAttachmentSampleLocationsEXT(
                vkStream, rootType,
                (const VkAttachmentSampleLocationsEXT*)(forMarshaling
                                                            ->pAttachmentInitialSampleLocations +
                                                        i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i) {
            marshal_VkSubpassSampleLocationsEXT(
                vkStream, rootType,
                (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations +
                                                     i));
        }
    }
}

void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount,
                   sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pAttachmentInitialSampleLocations,
                    forUnmarshaling->attachmentInitialSampleLocationsCount *
                        sizeof(const VkAttachmentSampleLocationsEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount;
             ++i) {
            unmarshal_VkAttachmentSampleLocationsEXT(
                vkStream, rootType,
                (VkAttachmentSampleLocationsEXT*)(forUnmarshaling
                                                      ->pAttachmentInitialSampleLocations +
                                                  i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPostSubpassSampleLocations,
                    forUnmarshaling->postSubpassSampleLocationsCount *
                        sizeof(const VkSubpassSampleLocationsEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i) {
            unmarshal_VkSubpassSampleLocationsEXT(
                vkStream, rootType,
                (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
        }
    }
}

void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
    marshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}

void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->sampleLocationsEnable, sizeof(VkBool32));
    unmarshal_VkSampleLocationsInfoEXT(
        vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}

void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts,
                    sizeof(VkSampleCountFlags));
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
    vkStream->write((float*)forMarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
    vkStream->write((uint32_t*)&forMarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->variableSampleLocations, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleLocationSampleCounts,
                   sizeof(VkSampleCountFlags));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
    vkStream->read((float*)forUnmarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
    vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->variableSampleLocations, sizeof(VkBool32));
}

void marshal_VkMultisamplePropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkMultisamplePropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
}

void unmarshal_VkMultisamplePropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkMultisamplePropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
}

#endif
#ifdef VK_EXT_blend_operation_advanced
void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->advancedBlendAllOperations, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedSrcColor,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedDstColor,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendAllOperations, sizeof(VkBool32));
}

void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
    vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
}

void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
    vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
}

#endif
#ifdef VK_NV_fragment_coverage_to_color
void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags,
                    sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
    vkStream->write((VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->coverageToColorLocation, sizeof(uint32_t));
}

void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCoverageToColorStateCreateFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
    vkStream->read((VkBool32*)&forUnmarshaling->coverageToColorEnable, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->coverageToColorLocation, sizeof(uint32_t));
}

#endif
#ifdef VK_NV_framebuffer_mixed_samples
void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags,
                    sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
    vkStream->write((VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode,
                    sizeof(VkCoverageModulationModeNV));
    vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pCoverageModulationTable) {
        vkStream->write((const float*)forMarshaling->pCoverageModulationTable,
                        forMarshaling->coverageModulationTableCount * sizeof(const float));
    }
}

void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCoverageModulationStateCreateFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
    vkStream->read((VkCoverageModulationModeNV*)&forUnmarshaling->coverageModulationMode,
                   sizeof(VkCoverageModulationModeNV));
    vkStream->read((VkBool32*)&forUnmarshaling->coverageModulationTableEnable, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->coverageModulationTableCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pCoverageModulationTable = (const float*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pCoverageModulationTable) {
        vkStream->alloc((void**)&forUnmarshaling->pCoverageModulationTable,
                        forUnmarshaling->coverageModulationTableCount * sizeof(const float));
        vkStream->read((float*)forUnmarshaling->pCoverageModulationTable,
                       forUnmarshaling->coverageModulationTableCount * sizeof(const float));
    }
}

#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->shaderSMCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderWarpsPerSM, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->shaderSMCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderWarpsPerSM, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderSMBuiltins, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSMBuiltins, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void marshal_VkDrmFormatModifierPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrmFormatModifierPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->drmFormatModifierTilingFeatures,
                    sizeof(VkFormatFeatureFlags));
}

void unmarshal_VkDrmFormatModifierPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkDrmFormatModifierPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->drmFormatModifierTilingFeatures,
                   sizeof(VkFormatFeatureFlags));
}

void marshal_VkDrmFormatModifierPropertiesListEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrmFormatModifierPropertiesListEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDrmFormatModifierProperties;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pDrmFormatModifierProperties) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
                marshal_VkDrmFormatModifierPropertiesEXT(
                    vkStream, rootType,
                    (VkDrmFormatModifierPropertiesEXT*)(forMarshaling
                                                            ->pDrmFormatModifierProperties +
                                                        i));
            }
        }
    }
}

void unmarshal_VkDrmFormatModifierPropertiesListEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDrmFormatModifierPropertiesListEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pDrmFormatModifierProperties =
        (VkDrmFormatModifierPropertiesEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDrmFormatModifierProperties) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pDrmFormatModifierProperties,
            forUnmarshaling->drmFormatModifierCount * sizeof(VkDrmFormatModifierPropertiesEXT));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i) {
                unmarshal_VkDrmFormatModifierPropertiesEXT(
                    vkStream, rootType,
                    (VkDrmFormatModifierPropertiesEXT*)(forUnmarshaling
                                                            ->pDrmFormatModifierProperties +
                                                        i));
            }
        }
    }
}

void marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pQueueFamilyIndices) {
        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
                        forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pQueueFamilyIndices) {
        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices,
                        forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
                       forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
    }
}

void marshal_VkImageDrmFormatModifierListCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierCount, sizeof(uint32_t));
    vkStream->write((const uint64_t*)forMarshaling->pDrmFormatModifiers,
                    forMarshaling->drmFormatModifierCount * sizeof(const uint64_t));
}

void unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDrmFormatModifiers,
                    forUnmarshaling->drmFormatModifierCount * sizeof(const uint64_t));
    vkStream->read((uint64_t*)forUnmarshaling->pDrmFormatModifiers,
                   forUnmarshaling->drmFormatModifierCount * sizeof(const uint64_t));
}

void marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i) {
            marshal_VkSubresourceLayout(
                vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i));
        }
    }
}

void unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pPlaneLayouts,
        forUnmarshaling->drmFormatModifierPlaneCount * sizeof(const VkSubresourceLayout));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierPlaneCount; ++i) {
            unmarshal_VkSubresourceLayout(
                vkStream, rootType, (VkSubresourceLayout*)(forUnmarshaling->pPlaneLayouts + i));
        }
    }
}

void marshal_VkImageDrmFormatModifierPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageDrmFormatModifierPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
}

void unmarshal_VkImageDrmFormatModifierPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
}

void marshal_VkDrmFormatModifierProperties2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrmFormatModifierProperties2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->drmFormatModifierTilingFeatures,
                    sizeof(VkFormatFeatureFlags2));
}

void unmarshal_VkDrmFormatModifierProperties2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDrmFormatModifierProperties2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->drmFormatModifierTilingFeatures,
                   sizeof(VkFormatFeatureFlags2));
}

void marshal_VkDrmFormatModifierPropertiesList2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrmFormatModifierPropertiesList2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDrmFormatModifierProperties;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pDrmFormatModifierProperties) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
                marshal_VkDrmFormatModifierProperties2EXT(
                    vkStream, rootType,
                    (VkDrmFormatModifierProperties2EXT*)(forMarshaling
                                                             ->pDrmFormatModifierProperties +
                                                         i));
            }
        }
    }
}

void unmarshal_VkDrmFormatModifierPropertiesList2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDrmFormatModifierPropertiesList2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pDrmFormatModifierProperties =
        (VkDrmFormatModifierProperties2EXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDrmFormatModifierProperties) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pDrmFormatModifierProperties,
            forUnmarshaling->drmFormatModifierCount * sizeof(VkDrmFormatModifierProperties2EXT));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i) {
                unmarshal_VkDrmFormatModifierProperties2EXT(
                    vkStream, rootType,
                    (VkDrmFormatModifierProperties2EXT*)(forUnmarshaling
                                                             ->pDrmFormatModifierProperties +
                                                         i));
            }
        }
    }
}

#endif
#ifdef VK_EXT_validation_cache
void marshal_VkValidationCacheCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkValidationCacheCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkValidationCacheCreateFlagsEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pInitialData,
                    forMarshaling->initialDataSize * sizeof(const uint8_t));
}

void unmarshal_VkValidationCacheCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkValidationCacheCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkValidationCacheCreateFlagsEXT));
    forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pInitialData,
                    forUnmarshaling->initialDataSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pInitialData,
                   forUnmarshaling->initialDataSize * sizeof(const uint8_t));
}

void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache,
                                                                   &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(
        &cgen_var_0, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
}

#endif
#ifdef VK_EXT_descriptor_indexing
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
void marshal_VkShadingRatePaletteNV(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkShadingRatePaletteNV* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->shadingRatePaletteEntryCount, sizeof(uint32_t));
    vkStream->write(
        (const VkShadingRatePaletteEntryNV*)forMarshaling->pShadingRatePaletteEntries,
        forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}

void unmarshal_VkShadingRatePaletteNV(VulkanStream* vkStream, VkStructureType rootType,
                                      VkShadingRatePaletteNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->shadingRatePaletteEntryCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pShadingRatePaletteEntries,
        forUnmarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
    vkStream->read(
        (VkShadingRatePaletteEntryNV*)forUnmarshaling->pShadingRatePaletteEntries,
        forUnmarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}

void marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shadingRateImageEnable, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pShadingRatePalettes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pShadingRatePalettes) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
                marshal_VkShadingRatePaletteNV(
                    vkStream, rootType,
                    (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i));
            }
        }
    }
}

void unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shadingRateImageEnable, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pShadingRatePalettes =
        (const VkShadingRatePaletteNV*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pShadingRatePalettes) {
        vkStream->alloc((void**)&forUnmarshaling->pShadingRatePalettes,
                        forUnmarshaling->viewportCount * sizeof(const VkShadingRatePaletteNV));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
                unmarshal_VkShadingRatePaletteNV(
                    vkStream, rootType,
                    (VkShadingRatePaletteNV*)(forUnmarshaling->pShadingRatePalettes + i));
            }
        }
    }
}

void marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shadingRateImage, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shadingRateCoarseSampleOrder, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shadingRateImage, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shadingRateCoarseSampleOrder, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateTexelSize));
    vkStream->write((uint32_t*)&forMarshaling->shadingRatePaletteSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->shadingRateTexelSize));
    vkStream->read((uint32_t*)&forUnmarshaling->shadingRatePaletteSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
}

void marshal_VkCoarseSampleLocationNV(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkCoarseSampleLocationNV* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->pixelX, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->pixelY, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sample, sizeof(uint32_t));
}

void unmarshal_VkCoarseSampleLocationNV(VulkanStream* vkStream, VkStructureType rootType,
                                        VkCoarseSampleLocationNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->pixelX, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->pixelY, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sample, sizeof(uint32_t));
}

void marshal_VkCoarseSampleOrderCustomNV(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkCoarseSampleOrderCustomNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate,
                    sizeof(VkShadingRatePaletteEntryNV));
    vkStream->write((uint32_t*)&forMarshaling->sampleCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sampleLocationCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i) {
            marshal_VkCoarseSampleLocationNV(
                vkStream, rootType,
                (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i));
        }
    }
}

void unmarshal_VkCoarseSampleOrderCustomNV(VulkanStream* vkStream, VkStructureType rootType,
                                           VkCoarseSampleOrderCustomNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkShadingRatePaletteEntryNV*)&forUnmarshaling->shadingRate,
                   sizeof(VkShadingRatePaletteEntryNV));
    vkStream->read((uint32_t*)&forUnmarshaling->sampleCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pSampleLocations,
                    forUnmarshaling->sampleLocationCount * sizeof(const VkCoarseSampleLocationNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationCount; ++i) {
            unmarshal_VkCoarseSampleLocationNV(
                vkStream, rootType,
                (VkCoarseSampleLocationNV*)(forUnmarshaling->pSampleLocations + i));
        }
    }
}

void marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkCoarseSampleOrderTypeNV*)&forMarshaling->sampleOrderType,
                    sizeof(VkCoarseSampleOrderTypeNV));
    vkStream->write((uint32_t*)&forMarshaling->customSampleOrderCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i) {
            marshal_VkCoarseSampleOrderCustomNV(
                vkStream, rootType,
                (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i));
        }
    }
}

void unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkCoarseSampleOrderTypeNV*)&forUnmarshaling->sampleOrderType,
                   sizeof(VkCoarseSampleOrderTypeNV));
    vkStream->read((uint32_t*)&forUnmarshaling->customSampleOrderCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pCustomSampleOrders,
        forUnmarshaling->customSampleOrderCount * sizeof(const VkCoarseSampleOrderCustomNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->customSampleOrderCount; ++i) {
            unmarshal_VkCoarseSampleOrderCustomNV(
                vkStream, rootType,
                (VkCoarseSampleOrderCustomNV*)(forUnmarshaling->pCustomSampleOrders + i));
        }
    }
}

#endif
#ifdef VK_NV_ray_tracing
void marshal_VkRayTracingShaderGroupCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRayTracingShaderGroupCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
                    sizeof(VkRayTracingShaderGroupTypeKHR));
    vkStream->write((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->anyHitShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->intersectionShader, sizeof(uint32_t));
}

void unmarshal_VkRayTracingShaderGroupCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type,
                   sizeof(VkRayTracingShaderGroupTypeKHR));
    vkStream->read((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->anyHitShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->intersectionShader, sizeof(uint32_t));
}

void marshal_VkRayTracingPipelineCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRayTracingPipelineCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
            marshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
            marshal_VkRayTracingShaderGroupCreateInfoNV(
                vkStream, rootType,
                (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
                                                               1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
                                                         &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}

void unmarshal_VkRayTracingPipelineCreateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                                VkRayTracingPipelineCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStages,
                    forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
            unmarshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pGroups,
        forUnmarshaling->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
            unmarshal_VkRayTracingShaderGroupCreateInfoNV(
                vkStream, rootType,
                (VkRayTracingShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxRecursionDepth, sizeof(uint32_t));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}

void marshal_VkGeometryTrianglesNV(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkGeometryTrianglesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->vertexData, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->vertexOffset, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->vertexStride, sizeof(VkDeviceSize));
    vkStream->write((VkFormat*)&forMarshaling->vertexFormat, sizeof(VkFormat));
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->indexData, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->indexOffset, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
    uint64_t cgen_var_2;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->transformData, &cgen_var_2,
                                                       1);
    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->transformOffset, sizeof(VkDeviceSize));
}

void unmarshal_VkGeometryTrianglesNV(VulkanStream* vkStream, VkStructureType rootType,
                                     VkGeometryTrianglesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->vertexData, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexOffset, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexStride, sizeof(VkDeviceSize));
    vkStream->read((VkFormat*)&forUnmarshaling->vertexFormat, sizeof(VkFormat));
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
                                                       (VkBuffer*)&forUnmarshaling->indexData, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->indexOffset, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
    uint64_t cgen_var_2;
    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(
        &cgen_var_2, (VkBuffer*)&forUnmarshaling->transformData, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->transformOffset, sizeof(VkDeviceSize));
}

void marshal_VkGeometryAABBNV(VulkanStream* vkStream, VkStructureType rootType,
                              const VkGeometryAABBNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->aabbData, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->numAABBs, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}

void unmarshal_VkGeometryAABBNV(VulkanStream* vkStream, VkStructureType rootType,
                                VkGeometryAABBNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->aabbData, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->numAABBs, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}

void marshal_VkGeometryDataNV(VulkanStream* vkStream, VkStructureType rootType,
                              const VkGeometryDataNV* forMarshaling) {
    (void)rootType;
    marshal_VkGeometryTrianglesNV(vkStream, rootType,
                                  (VkGeometryTrianglesNV*)(&forMarshaling->triangles));
    marshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forMarshaling->aabbs));
}

void unmarshal_VkGeometryDataNV(VulkanStream* vkStream, VkStructureType rootType,
                                VkGeometryDataNV* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkGeometryTrianglesNV(vkStream, rootType,
                                    (VkGeometryTrianglesNV*)(&forUnmarshaling->triangles));
    unmarshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forUnmarshaling->aabbs));
}

void marshal_VkGeometryNV(VulkanStream* vkStream, VkStructureType rootType,
                          const VkGeometryNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkGeometryTypeKHR*)&forMarshaling->geometryType, sizeof(VkGeometryTypeKHR));
    marshal_VkGeometryDataNV(vkStream, rootType, (VkGeometryDataNV*)(&forMarshaling->geometry));
    vkStream->write((VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
}

void unmarshal_VkGeometryNV(VulkanStream* vkStream, VkStructureType rootType,
                            VkGeometryNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkGeometryTypeKHR*)&forUnmarshaling->geometryType, sizeof(VkGeometryTypeKHR));
    unmarshal_VkGeometryDataNV(vkStream, rootType, (VkGeometryDataNV*)(&forUnmarshaling->geometry));
    vkStream->read((VkGeometryFlagsKHR*)&forUnmarshaling->flags, sizeof(VkGeometryFlagsKHR));
}

void marshal_VkAccelerationStructureInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkAccelerationStructureInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccelerationStructureTypeNV*)&forMarshaling->type,
                    sizeof(VkAccelerationStructureTypeNV));
    vkStream->write((VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags,
                    sizeof(VkBuildAccelerationStructureFlagsNV));
    vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
            marshal_VkGeometryNV(vkStream, rootType,
                                 (const VkGeometryNV*)(forMarshaling->pGeometries + i));
        }
    }
}

void unmarshal_VkAccelerationStructureInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                             VkAccelerationStructureInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccelerationStructureTypeNV*)&forUnmarshaling->type,
                   sizeof(VkAccelerationStructureTypeNV));
    vkStream->read((VkBuildAccelerationStructureFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkBuildAccelerationStructureFlagsNV));
    vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->geometryCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pGeometries,
                    forUnmarshaling->geometryCount * sizeof(const VkGeometryNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i) {
            unmarshal_VkGeometryNV(vkStream, rootType,
                                   (VkGeometryNV*)(forUnmarshaling->pGeometries + i));
        }
    }
}

void marshal_VkAccelerationStructureCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->compactedSize, sizeof(VkDeviceSize));
    marshal_VkAccelerationStructureInfoNV(vkStream, rootType,
                                          (VkAccelerationStructureInfoNV*)(&forMarshaling->info));
}

void unmarshal_VkAccelerationStructureCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->compactedSize, sizeof(VkDeviceSize));
    unmarshal_VkAccelerationStructureInfoNV(
        vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forUnmarshaling->info));
}

void marshal_VkBindAccelerationStructureMemoryInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindAccelerationStructureMemoryInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
        &forMarshaling->accelerationStructure, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
                    forMarshaling->deviceIndexCount * sizeof(const uint32_t));
}

void unmarshal_VkBindAccelerationStructureMemoryInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
        &cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices,
                    forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
                   forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
}

void marshal_VkWriteDescriptorSetAccelerationStructureNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAccelerationStructures) {
        if (forMarshaling->accelerationStructureCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
            vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
                forMarshaling->pAccelerationStructures, cgen_var_0_0,
                forMarshaling->accelerationStructureCount);
            vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
        }
    }
}

void unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->accelerationStructureCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pAccelerationStructures =
        (const VkAccelerationStructureNV*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAccelerationStructures) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pAccelerationStructures,
            forUnmarshaling->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
        if (forUnmarshaling->accelerationStructureCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
            vkStream->read((uint64_t*)cgen_var_0_0,
                           forUnmarshaling->accelerationStructureCount * 8);
            vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
                cgen_var_0_0, (VkAccelerationStructureNV*)forUnmarshaling->pAccelerationStructures,
                forUnmarshaling->accelerationStructureCount);
        }
    }
}

void marshal_VkAccelerationStructureMemoryRequirementsInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type,
                    sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
        &forMarshaling->accelerationStructure, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccelerationStructureMemoryRequirementsTypeNV*)&forUnmarshaling->type,
                   sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
        &cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
}

void marshal_VkPhysicalDeviceRayTracingPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
    vkStream->write((uint64_t*)&forMarshaling->maxGeometryCount, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->maxInstanceCount, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->maxTriangleCount, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxRecursionDepth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxGeometryCount, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxInstanceCount, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxTriangleCount, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures,
                   sizeof(uint32_t));
}

void marshal_VkTransformMatrixKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkTransformMatrixKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)forMarshaling->matrix, ((3) * (4)) * sizeof(float));
}

void unmarshal_VkTransformMatrixKHR(VulkanStream* vkStream, VkStructureType rootType,
                                    VkTransformMatrixKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)forUnmarshaling->matrix, ((3) * (4)) * sizeof(float));
}

void marshal_VkAabbPositionsKHR(VulkanStream* vkStream, VkStructureType rootType,
                                const VkAabbPositionsKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->minX, sizeof(float));
    vkStream->write((float*)&forMarshaling->minY, sizeof(float));
    vkStream->write((float*)&forMarshaling->minZ, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxX, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxY, sizeof(float));
    vkStream->write((float*)&forMarshaling->maxZ, sizeof(float));
}

void unmarshal_VkAabbPositionsKHR(VulkanStream* vkStream, VkStructureType rootType,
                                  VkAabbPositionsKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->minX, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->minY, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->minZ, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxX, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxY, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->maxZ, sizeof(float));
}

void marshal_VkAccelerationStructureInstanceKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureInstanceKHR* forMarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
        VkTransformMatrixKHR transform;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureInstanceKHRWithoutBitFields;

    const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new =
        (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
    marshal_VkTransformMatrixKHR(vkStream, rootType,
                                 (VkTransformMatrixKHR*)(&forMarshaling_new->transform));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
                    sizeof(uint64_t));
}

void unmarshal_VkAccelerationStructureInstanceKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureInstanceKHR* forUnmarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
        VkTransformMatrixKHR transform;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureInstanceKHRWithoutBitFields;

    VkAccelerationStructureInstanceKHRWithoutBitFields* forUnmarshaling_new =
        (VkAccelerationStructureInstanceKHRWithoutBitFields*)(forUnmarshaling);
    unmarshal_VkTransformMatrixKHR(vkStream, rootType,
                                   (VkTransformMatrixKHR*)(&forUnmarshaling_new->transform));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
                   sizeof(uint64_t));
}

#endif
#ifdef VK_NV_representative_fragment_test
void marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->representativeFragmentTest, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->representativeFragmentTest, sizeof(VkBool32));
}

void marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->representativeFragmentTestEnable, sizeof(VkBool32));
}

void unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->representativeFragmentTestEnable, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_filter_cubic
void marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageViewType*)&forMarshaling->imageViewType, sizeof(VkImageViewType));
}

void unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageViewType*)&forUnmarshaling->imageViewType, sizeof(VkImageViewType));
}

void marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->filterCubic, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->filterCubicMinmax, sizeof(VkBool32));
}

void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->filterCubic, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->filterCubicMinmax, sizeof(VkBool32));
}

#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
#endif
#ifdef VK_EXT_external_memory_host
void marshal_VkImportMemoryHostPointerInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportMemoryHostPointerInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pHostPointer) {
        vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
    }
}

void unmarshal_VkImportMemoryHostPointerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkImportMemoryHostPointerInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
    // WARNING PTR CHECK
    forUnmarshaling->pHostPointer = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pHostPointer) {
        vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
    }
}

void marshal_VkMemoryHostPointerPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryHostPointerPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkMemoryHostPointerPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkMemoryHostPointerPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment,
                    sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment,
                   sizeof(VkDeviceSize));
}

#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void marshal_VkPipelineCompilerControlCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineCompilerControlCreateInfoAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags,
                    sizeof(VkPipelineCompilerControlFlagsAMD));
}

void unmarshal_VkPipelineCompilerControlCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCompilerControlFlagsAMD*)&forUnmarshaling->compilerControlFlags,
                   sizeof(VkPipelineCompilerControlFlagsAMD));
}

#endif
#ifdef VK_EXT_calibrated_timestamps
void marshal_VkCalibratedTimestampInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkCalibratedTimestampInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkTimeDomainEXT*)&forMarshaling->timeDomain, sizeof(VkTimeDomainEXT));
}

void unmarshal_VkCalibratedTimestampInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            VkCalibratedTimestampInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkTimeDomainEXT*)&forUnmarshaling->timeDomain, sizeof(VkTimeDomainEXT));
}

#endif
#ifdef VK_AMD_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->shaderEngineCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->simdPerComputeUnit, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->wavefrontsPerSimd, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->wavefrontSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sgprsPerSimd, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minSgprAllocation, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSgprAllocation, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sgprAllocationGranularity, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vgprsPerSimd, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minVgprAllocation, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxVgprAllocation, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vgprAllocationGranularity, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->shaderEngineCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->simdPerComputeUnit, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->wavefrontsPerSimd, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->wavefrontSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sgprsPerSimd, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minSgprAllocation, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSgprAllocation, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sgprAllocationGranularity, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vgprsPerSimd, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minVgprAllocation, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVgprAllocation, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vgprAllocationGranularity, sizeof(uint32_t));
}

#endif
#ifdef VK_AMD_memory_overallocation_behavior
void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior,
                    sizeof(VkMemoryOverallocationBehaviorAMD));
}

void unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMemoryOverallocationBehaviorAMD*)&forUnmarshaling->overallocationBehavior,
                   sizeof(VkMemoryOverallocationBehaviorAMD));
}

#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
}

void marshal_VkVertexInputBindingDivisorDescriptionEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
}

void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
}

void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i) {
            marshal_VkVertexInputBindingDivisorDescriptionEXT(
                vkStream, rootType,
                (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling
                                                                       ->pVertexBindingDivisors +
                                                                   i));
        }
    }
}

void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDivisors,
                    forUnmarshaling->vertexBindingDivisorCount *
                        sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i) {
            unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
                vkStream, rootType,
                (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling
                                                                 ->pVertexBindingDivisors +
                                                             i));
        }
    }
}

void marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateDivisor,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateZeroDivisor,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_GGP_frame_token
void marshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkPresentFrameTokenGGP* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((GgpFrameToken*)&forMarshaling->frameToken, sizeof(GgpFrameToken));
}

void unmarshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructureType rootType,
                                      VkPresentFrameTokenGGP* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((GgpFrameToken*)&forUnmarshaling->frameToken, sizeof(GgpFrameToken));
}

#endif
#ifdef VK_EXT_pipeline_creation_feedback
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->computeDerivativeGroupQuads, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->computeDerivativeGroupLinear, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->computeDerivativeGroupQuads, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->computeDerivativeGroupLinear, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->taskShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->meshShader, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->taskShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->meshShader, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxDrawMeshTasksCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskTotalMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskOutputCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshTotalMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputVertices, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerPrimitiveGranularity, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxDrawMeshTasksCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskTotalMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskOutputCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshTotalMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputVertices, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity,
                   sizeof(uint32_t));
}

void marshal_VkDrawMeshTasksIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrawMeshTasksIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->taskCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstTask, sizeof(uint32_t));
}

void unmarshal_VkDrawMeshTasksIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
                                                VkDrawMeshTasksIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->taskCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstTask, sizeof(uint32_t));
}

#endif
#ifdef VK_NV_fragment_shader_barycentric
#endif
#ifdef VK_NV_shader_image_footprint
void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->imageFootprint, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->imageFootprint, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_scissor_exclusive
void marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->exclusiveScissorCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pExclusiveScissors;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pExclusiveScissors) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i) {
                marshal_VkRect2D(vkStream, rootType,
                                 (const VkRect2D*)(forMarshaling->pExclusiveScissors + i));
            }
        }
    }
}

void unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->exclusiveScissorCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pExclusiveScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pExclusiveScissors) {
        vkStream->alloc((void**)&forUnmarshaling->pExclusiveScissors,
                        forUnmarshaling->exclusiveScissorCount * sizeof(const VkRect2D));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->exclusiveScissorCount; ++i) {
                unmarshal_VkRect2D(vkStream, rootType,
                                   (VkRect2D*)(forUnmarshaling->pExclusiveScissors + i));
            }
        }
    }
}

void marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->exclusiveScissor, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->exclusiveScissor, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void marshal_VkQueueFamilyCheckpointPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueueFamilyCheckpointPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask,
                    sizeof(VkPipelineStageFlags));
}

void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask,
                   sizeof(VkPipelineStageFlags));
}

void marshal_VkCheckpointDataNV(VulkanStream* vkStream, VkStructureType rootType,
                                const VkCheckpointDataNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage,
                    sizeof(VkPipelineStageFlagBits));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pCheckpointMarker) {
        vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
    }
}

void unmarshal_VkCheckpointDataNV(VulkanStream* vkStream, VkStructureType rootType,
                                  VkCheckpointDataNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage,
                   sizeof(VkPipelineStageFlagBits));
    // WARNING PTR CHECK
    forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pCheckpointMarker) {
        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
    }
}

#endif
#ifdef VK_INTEL_shader_integer_functions2
void marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerFunctions2, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerFunctions2, sizeof(VkBool32));
}

#endif
#ifdef VK_INTEL_performance_query
void marshal_VkPerformanceValueDataINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkPerformanceValueDataINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->value32, sizeof(uint32_t));
}

void unmarshal_VkPerformanceValueDataINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                           VkPerformanceValueDataINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->value32, sizeof(uint32_t));
}

void marshal_VkPerformanceValueINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkPerformanceValueINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkPerformanceValueTypeINTEL*)&forMarshaling->type,
                    sizeof(VkPerformanceValueTypeINTEL));
    marshal_VkPerformanceValueDataINTEL(vkStream, rootType,
                                        (VkPerformanceValueDataINTEL*)(&forMarshaling->data));
}

void unmarshal_VkPerformanceValueINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                       VkPerformanceValueINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkPerformanceValueTypeINTEL*)&forUnmarshaling->type,
                   sizeof(VkPerformanceValueTypeINTEL));
    unmarshal_VkPerformanceValueDataINTEL(vkStream, rootType,
                                          (VkPerformanceValueDataINTEL*)(&forUnmarshaling->data));
}

void marshal_VkInitializePerformanceApiInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkInitializePerformanceApiInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pUserData) {
        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
    }
}

void unmarshal_VkInitializePerformanceApiInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    VkInitializePerformanceApiInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUserData) {
        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
    }
}

void marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling,
                    sizeof(VkQueryPoolSamplingModeINTEL));
}

void unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkQueryPoolSamplingModeINTEL*)&forUnmarshaling->performanceCountersSampling,
                   sizeof(VkQueryPoolSamplingModeINTEL));
}

void marshal_VkPerformanceMarkerInfoINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkPerformanceMarkerInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->marker, sizeof(uint64_t));
}

void unmarshal_VkPerformanceMarkerInfoINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                            VkPerformanceMarkerInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->marker, sizeof(uint64_t));
}

void marshal_VkPerformanceStreamMarkerInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPerformanceStreamMarkerInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->marker, sizeof(uint32_t));
}

void unmarshal_VkPerformanceStreamMarkerInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->marker, sizeof(uint32_t));
}

void marshal_VkPerformanceOverrideInfoINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkPerformanceOverrideInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPerformanceOverrideTypeINTEL*)&forMarshaling->type,
                    sizeof(VkPerformanceOverrideTypeINTEL));
    vkStream->write((VkBool32*)&forMarshaling->enable, sizeof(VkBool32));
    vkStream->write((uint64_t*)&forMarshaling->parameter, sizeof(uint64_t));
}

void unmarshal_VkPerformanceOverrideInfoINTEL(VulkanStream* vkStream, VkStructureType rootType,
                                              VkPerformanceOverrideInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPerformanceOverrideTypeINTEL*)&forUnmarshaling->type,
                   sizeof(VkPerformanceOverrideTypeINTEL));
    vkStream->read((VkBool32*)&forUnmarshaling->enable, sizeof(VkBool32));
    vkStream->read((uint64_t*)&forUnmarshaling->parameter, sizeof(uint64_t));
}

void marshal_VkPerformanceConfigurationAcquireInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type,
                    sizeof(VkPerformanceConfigurationTypeINTEL));
}

void unmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPerformanceConfigurationTypeINTEL*)&forUnmarshaling->type,
                   sizeof(VkPerformanceConfigurationTypeINTEL));
}

#endif
#ifdef VK_EXT_pci_bus_info
void marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->pciDomain, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->pciBus, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->pciDevice, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->pciFunction, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->pciDomain, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->pciBus, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->pciDevice, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->pciFunction, sizeof(uint32_t));
}

#endif
#ifdef VK_AMD_display_native_hdr
void marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->localDimmingSupport, sizeof(VkBool32));
}

void unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->localDimmingSupport, sizeof(VkBool32));
}

void marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->localDimmingEnable, sizeof(VkBool32));
}

void unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->localDimmingEnable, sizeof(VkBool32));
}

#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void marshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forMarshaling->flags,
                    sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
    vkStream->write((zx_handle_t*)&forMarshaling->imagePipeHandle, sizeof(zx_handle_t));
}

void unmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forUnmarshaling->flags,
                   sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
    vkStream->read((zx_handle_t*)&forUnmarshaling->imagePipeHandle, sizeof(zx_handle_t));
}

#endif
#ifdef VK_EXT_metal_surface
void marshal_VkMetalSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkMetalSurfaceCreateInfoEXT* forMarshaling) {
    (void)rootType;

    // This struct should never be marshaled / unmarshaled.
    __builtin_trap();
}

void unmarshal_VkMetalSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkMetalSurfaceCreateInfoEXT* forUnmarshaling) {
    (void)rootType;

    // This struct should never be marshaled / unmarshaled.
    __builtin_trap();
}

#endif
#ifdef VK_EXT_fragment_density_map
void marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMap, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMap, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapNonSubsampledImages,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->minFragmentDensityTexelSize));
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->maxFragmentDensityTexelSize));
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->minFragmentDensityTexelSize));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->maxFragmentDensityTexelSize));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}

void marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkAttachmentReference(
        vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment));
}

void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkAttachmentReference(
        vkStream, rootType,
        (VkAttachmentReference*)(&forUnmarshaling->fragmentDensityMapAttachment));
}

#endif
#ifdef VK_EXT_scalar_block_layout
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
#endif
#ifdef VK_GOOGLE_decorate_string
#endif
#ifdef VK_EXT_subgroup_size_control
#endif
#ifdef VK_AMD_shader_core_properties2
void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderCorePropertiesFlagsAMD*)&forMarshaling->shaderCoreFeatures,
                    sizeof(VkShaderCorePropertiesFlagsAMD));
    vkStream->write((uint32_t*)&forMarshaling->activeComputeUnitCount, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderCorePropertiesFlagsAMD*)&forUnmarshaling->shaderCoreFeatures,
                   sizeof(VkShaderCorePropertiesFlagsAMD));
    vkStream->read((uint32_t*)&forUnmarshaling->activeComputeUnitCount, sizeof(uint32_t));
}

#endif
#ifdef VK_AMD_device_coherent_memory
void marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->deviceCoherentMemory, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->deviceCoherentMemory, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_shader_image_atomic_int64
void marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderImageInt64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseImageInt64Atomics, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageInt64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseImageInt64Atomics, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_memory_budget
void marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)forMarshaling->heapBudget,
                    VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)forMarshaling->heapUsage,
                    VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)forUnmarshaling->heapBudget,
                   VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)forUnmarshaling->heapUsage,
                   VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
}

#endif
#ifdef VK_EXT_memory_priority
void marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->memoryPriority, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->memoryPriority, sizeof(VkBool32));
}

void marshal_VkMemoryPriorityAllocateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkMemoryPriorityAllocateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((float*)&forMarshaling->priority, sizeof(float));
}

void unmarshal_VkMemoryPriorityAllocateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkMemoryPriorityAllocateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((float*)&forUnmarshaling->priority, sizeof(float));
}

#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocationImageAliasing, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocationImageAliasing, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_buffer_device_address
void marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddress, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
}

void marshal_VkBufferDeviceAddressCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferDeviceAddressCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

#endif
#ifdef VK_EXT_tooling_info
#endif
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
void marshal_VkValidationFeaturesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkValidationFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->enabledValidationFeatureCount, sizeof(uint32_t));
    vkStream->write(
        (const VkValidationFeatureEnableEXT*)forMarshaling->pEnabledValidationFeatures,
        forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
    vkStream->write((uint32_t*)&forMarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
    vkStream->write(
        (const VkValidationFeatureDisableEXT*)forMarshaling->pDisabledValidationFeatures,
        forMarshaling->disabledValidationFeatureCount *
            sizeof(const VkValidationFeatureDisableEXT));
}

void unmarshal_VkValidationFeaturesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkValidationFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->enabledValidationFeatureCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pEnabledValidationFeatures,
                    forUnmarshaling->enabledValidationFeatureCount *
                        sizeof(const VkValidationFeatureEnableEXT));
    vkStream->read((VkValidationFeatureEnableEXT*)forUnmarshaling->pEnabledValidationFeatures,
                   forUnmarshaling->enabledValidationFeatureCount *
                       sizeof(const VkValidationFeatureEnableEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDisabledValidationFeatures,
                    forUnmarshaling->disabledValidationFeatureCount *
                        sizeof(const VkValidationFeatureDisableEXT));
    vkStream->read((VkValidationFeatureDisableEXT*)forUnmarshaling->pDisabledValidationFeatures,
                   forUnmarshaling->disabledValidationFeatureCount *
                       sizeof(const VkValidationFeatureDisableEXT));
}

#endif
#ifdef VK_NV_cooperative_matrix
void marshal_VkCooperativeMatrixPropertiesNV(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkCooperativeMatrixPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->MSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->NSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->KSize, sizeof(uint32_t));
    vkStream->write((VkComponentTypeNV*)&forMarshaling->AType, sizeof(VkComponentTypeNV));
    vkStream->write((VkComponentTypeNV*)&forMarshaling->BType, sizeof(VkComponentTypeNV));
    vkStream->write((VkComponentTypeNV*)&forMarshaling->CType, sizeof(VkComponentTypeNV));
    vkStream->write((VkComponentTypeNV*)&forMarshaling->DType, sizeof(VkComponentTypeNV));
    vkStream->write((VkScopeNV*)&forMarshaling->scope, sizeof(VkScopeNV));
}

void unmarshal_VkCooperativeMatrixPropertiesNV(VulkanStream* vkStream, VkStructureType rootType,
                                               VkCooperativeMatrixPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->MSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->NSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->KSize, sizeof(uint32_t));
    vkStream->read((VkComponentTypeNV*)&forUnmarshaling->AType, sizeof(VkComponentTypeNV));
    vkStream->read((VkComponentTypeNV*)&forUnmarshaling->BType, sizeof(VkComponentTypeNV));
    vkStream->read((VkComponentTypeNV*)&forUnmarshaling->CType, sizeof(VkComponentTypeNV));
    vkStream->read((VkComponentTypeNV*)&forUnmarshaling->DType, sizeof(VkComponentTypeNV));
    vkStream->read((VkScopeNV*)&forUnmarshaling->scope, sizeof(VkScopeNV));
}

void marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->cooperativeMatrix, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->cooperativeMatrixRobustBufferAccess,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->cooperativeMatrix, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->cooperativeMatrixRobustBufferAccess,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages,
                    sizeof(VkShaderStageFlags));
}

void unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->cooperativeMatrixSupportedStages,
                   sizeof(VkShaderStageFlags));
}

#endif
#ifdef VK_NV_coverage_reduction_mode
void marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->coverageReductionMode, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->coverageReductionMode, sizeof(VkBool32));
}

void marshal_VkPipelineCoverageReductionStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCoverageReductionStateCreateFlagsNV*)&forMarshaling->flags,
                    sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
    vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
                    sizeof(VkCoverageReductionModeNV));
}

void unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCoverageReductionStateCreateFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
    vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode,
                   sizeof(VkCoverageReductionModeNV));
}

void marshal_VkFramebufferMixedSamplesCombinationNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkFramebufferMixedSamplesCombinationNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
                    sizeof(VkCoverageReductionModeNV));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
                    sizeof(VkSampleCountFlagBits));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->depthStencilSamples,
                    sizeof(VkSampleCountFlags));
    vkStream->write((VkSampleCountFlags*)&forMarshaling->colorSamples, sizeof(VkSampleCountFlags));
}

void unmarshal_VkFramebufferMixedSamplesCombinationNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkFramebufferMixedSamplesCombinationNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode,
                   sizeof(VkCoverageReductionModeNV));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
                   sizeof(VkSampleCountFlagBits));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->depthStencilSamples,
                   sizeof(VkSampleCountFlags));
    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->colorSamples, sizeof(VkSampleCountFlags));
}

#endif
#ifdef VK_EXT_fragment_shader_interlock
void marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderSampleInterlock, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderPixelInterlock, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderShadingRateInterlock,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderSampleInterlock, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderPixelInterlock, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderShadingRateInterlock,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_ycbcr_image_arrays
void marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->ycbcrImageArrays, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->ycbcrImageArrays, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_provoking_vertex
void marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->provokingVertexLast, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesProvokingVertex,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceProvokingVertexFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->provokingVertexLast, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackPreservesProvokingVertex,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->provokingVertexModePerPipeline, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesTriangleFanProvokingVertex,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceProvokingVertexPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->provokingVertexModePerPipeline, sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->transformFeedbackPreservesTriangleFanProvokingVertex,
        sizeof(VkBool32));
}

void marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkProvokingVertexModeEXT*)&forMarshaling->provokingVertexMode,
                    sizeof(VkProvokingVertexModeEXT));
}

void unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkProvokingVertexModeEXT*)&forUnmarshaling->provokingVertexMode,
                   sizeof(VkProvokingVertexModeEXT));
}

#endif
#ifdef VK_EXT_full_screen_exclusive
void marshal_VkSurfaceFullScreenExclusiveInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive,
                    sizeof(VkFullScreenExclusiveEXT));
}

void unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFullScreenExclusiveEXT*)&forUnmarshaling->fullScreenExclusive,
                   sizeof(VkFullScreenExclusiveEXT));
}

void marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fullScreenExclusiveSupported, sizeof(VkBool32));
}

void unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fullScreenExclusiveSupported, sizeof(VkBool32));
}

void marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((HMONITOR*)&forMarshaling->hmonitor, sizeof(HMONITOR));
}

void unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((HMONITOR*)&forUnmarshaling->hmonitor, sizeof(HMONITOR));
}

#endif
#ifdef VK_EXT_headless_surface
void marshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkHeadlessSurfaceCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkHeadlessSurfaceCreateFlagsEXT));
}

void unmarshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkHeadlessSurfaceCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkHeadlessSurfaceCreateFlagsEXT));
}

#endif
#ifdef VK_EXT_line_rasterization
void marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rectangularLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bresenhamLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->smoothLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->stippledRectangularLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->stippledBresenhamLines, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->stippledSmoothLines, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
}

void marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkLineRasterizationModeEXT*)&forMarshaling->lineRasterizationMode,
                    sizeof(VkLineRasterizationModeEXT));
    vkStream->write((VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
    vkStream->write((uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
}

void unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkLineRasterizationModeEXT*)&forUnmarshaling->lineRasterizationMode,
                   sizeof(VkLineRasterizationModeEXT));
    vkStream->read((VkBool32*)&forUnmarshaling->stippledLineEnable, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->lineStippleFactor, sizeof(uint32_t));
    vkStream->read((uint16_t*)&forUnmarshaling->lineStipplePattern, sizeof(uint16_t));
}

#endif
#ifdef VK_EXT_shader_atomic_float
void marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat32Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat64AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat32Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat64Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat64AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderImageFloat32Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderImageFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseImageFloat32Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseImageFloat32AtomicAdd, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat32Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat64AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat32Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat64Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat64AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageFloat32Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageFloat32AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseImageFloat32Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseImageFloat32AtomicAdd, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_host_query_reset
#endif
#ifdef VK_EXT_index_type_uint8
void marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->indexTypeUint8, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_extended_dynamic_state
void marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_shader_atomic_float2
void marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat16Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat16AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat16AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat64AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat16Atomics, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat16AtomicAdd, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat16AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderSharedFloat64AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderImageFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sparseImageFloat32AtomicMinMax, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat16Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat16AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat16AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat64AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat16Atomics, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat16AtomicAdd, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat16AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedFloat64AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageFloat32AtomicMinMax, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sparseImageFloat32AtomicMinMax, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_surface_maintenance1
void marshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkSurfacePresentModeEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
}

void unmarshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkSurfacePresentModeEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
}

void marshal_VkSurfacePresentScalingCapabilitiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfacePresentScalingCapabilitiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPresentScalingFlagsEXT*)&forMarshaling->supportedPresentScaling,
                    sizeof(VkPresentScalingFlagsEXT));
    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->supportedPresentGravityX,
                    sizeof(VkPresentGravityFlagsEXT));
    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->supportedPresentGravityY,
                    sizeof(VkPresentGravityFlagsEXT));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minScaledImageExtent));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxScaledImageExtent));
}

void unmarshal_VkSurfacePresentScalingCapabilitiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfacePresentScalingCapabilitiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPresentScalingFlagsEXT*)&forUnmarshaling->supportedPresentScaling,
                   sizeof(VkPresentScalingFlagsEXT));
    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityX,
                   sizeof(VkPresentGravityFlagsEXT));
    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityY,
                   sizeof(VkPresentGravityFlagsEXT));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minScaledImageExtent));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxScaledImageExtent));
}

void marshal_VkSurfacePresentModeCompatibilityEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfacePresentModeCompatibilityEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->presentModeCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPresentModes;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pPresentModes) {
        vkStream->write((VkPresentModeKHR*)forMarshaling->pPresentModes,
                        forMarshaling->presentModeCount * sizeof(VkPresentModeKHR));
    }
}

void unmarshal_VkSurfacePresentModeCompatibilityEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfacePresentModeCompatibilityEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->presentModeCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pPresentModes = (VkPresentModeKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pPresentModes) {
        vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
                        forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
        vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
                       forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
    }
}

#endif
#ifdef VK_EXT_swapchain_maintenance1
void marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->swapchainMaintenance1, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->swapchainMaintenance1, sizeof(VkBool32));
}

void marshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkSwapchainPresentFenceInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    if (forMarshaling->swapchainCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->swapchainCount * 8);
        vkStream->handleMapping()->mapHandles_VkFence_u64(forMarshaling->pFences, cgen_var_0,
                                                          forMarshaling->swapchainCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->swapchainCount * 8);
    }
}

void unmarshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkSwapchainPresentFenceInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pFences,
                    forUnmarshaling->swapchainCount * sizeof(const VkFence));
    if (forUnmarshaling->swapchainCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->swapchainCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->swapchainCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkFence(
            cgen_var_0, (VkFence*)forUnmarshaling->pFences, forUnmarshaling->swapchainCount);
    }
}

void marshal_VkSwapchainPresentModesCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSwapchainPresentModesCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->presentModeCount, sizeof(uint32_t));
    vkStream->write((const VkPresentModeKHR*)forMarshaling->pPresentModes,
                    forMarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
}

void unmarshal_VkSwapchainPresentModesCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSwapchainPresentModesCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->presentModeCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
                    forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
    vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
                   forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
}

void marshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkSwapchainPresentModeInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->write((const VkPresentModeKHR*)forMarshaling->pPresentModes,
                    forMarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
}

void unmarshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkSwapchainPresentModeInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
                    forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
    vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
                   forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
}

void marshal_VkSwapchainPresentScalingCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSwapchainPresentScalingCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPresentScalingFlagsEXT*)&forMarshaling->scalingBehavior,
                    sizeof(VkPresentScalingFlagsEXT));
    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->presentGravityX,
                    sizeof(VkPresentGravityFlagsEXT));
    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->presentGravityY,
                    sizeof(VkPresentGravityFlagsEXT));
}

void unmarshal_VkSwapchainPresentScalingCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSwapchainPresentScalingCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPresentScalingFlagsEXT*)&forUnmarshaling->scalingBehavior,
                   sizeof(VkPresentScalingFlagsEXT));
    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityX,
                   sizeof(VkPresentGravityFlagsEXT));
    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityY,
                   sizeof(VkPresentGravityFlagsEXT));
}

void marshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkReleaseSwapchainImagesInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->imageIndexCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pImageIndices,
                    forMarshaling->imageIndexCount * sizeof(const uint32_t));
}

void unmarshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkReleaseSwapchainImagesInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
        &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->imageIndexCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pImageIndices,
                    forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pImageIndices,
                   forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
}

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
#endif
#ifdef VK_NV_device_generated_commands
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxGraphicsShaderGroupCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxIndirectSequenceCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsTokenCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsStreamCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsTokenOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsStreamStride, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minSequencesCountBufferOffsetAlignment,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minSequencesIndexBufferOffsetAlignment,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minIndirectCommandsBufferOffsetAlignment,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxGraphicsShaderGroupCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectSequenceCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsTokenCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsStreamCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsTokenOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsStreamStride, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minSequencesCountBufferOffsetAlignment,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minSequencesIndexBufferOffsetAlignment,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minIndirectCommandsBufferOffsetAlignment,
                   sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->deviceGeneratedCommands, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->deviceGeneratedCommands, sizeof(VkBool32));
}

void marshal_VkGraphicsShaderGroupCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkGraphicsShaderGroupCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
            marshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pVertexInputState) {
        marshal_VkPipelineVertexInputStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pTessellationState) {
        marshal_VkPipelineTessellationStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
    }
}

void unmarshal_VkGraphicsShaderGroupCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStages,
                    forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
            unmarshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pVertexInputState =
        (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pVertexInputState) {
        vkStream->alloc((void**)&forUnmarshaling->pVertexInputState,
                        sizeof(const VkPipelineVertexInputStateCreateInfo));
        unmarshal_VkPipelineVertexInputStateCreateInfo(
            vkStream, rootType,
            (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pTessellationState =
        (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pTessellationState) {
        vkStream->alloc((void**)&forUnmarshaling->pTessellationState,
                        sizeof(const VkPipelineTessellationStateCreateInfo));
        unmarshal_VkPipelineTessellationStateCreateInfo(
            vkStream, rootType,
            (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
    }
}

void marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
            marshal_VkGraphicsShaderGroupCreateInfoNV(
                vkStream, rootType,
                (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->pipelineCount, sizeof(uint32_t));
    if (forMarshaling->pipelineCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forMarshaling->pipelineCount * 8);
        vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pPipelines, cgen_var_0,
                                                             forMarshaling->pipelineCount);
        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->pipelineCount * 8);
    }
}

void unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pGroups,
                    forUnmarshaling->groupCount * sizeof(const VkGraphicsShaderGroupCreateInfoNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
            unmarshal_VkGraphicsShaderGroupCreateInfoNV(
                vkStream, rootType,
                (VkGraphicsShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->pipelineCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPipelines,
                    forUnmarshaling->pipelineCount * sizeof(const VkPipeline));
    if (forUnmarshaling->pipelineCount) {
        uint64_t* cgen_var_0;
        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->pipelineCount * 8);
        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->pipelineCount * 8);
        vkStream->handleMapping()->mapHandles_u64_VkPipeline(
            cgen_var_0, (VkPipeline*)forUnmarshaling->pPipelines, forUnmarshaling->pipelineCount);
    }
}

void marshal_VkBindShaderGroupIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindShaderGroupIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->groupIndex, sizeof(uint32_t));
}

void unmarshal_VkBindShaderGroupIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindShaderGroupIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->groupIndex, sizeof(uint32_t));
}

void marshal_VkBindIndexBufferIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindIndexBufferIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
}

void unmarshal_VkBindIndexBufferIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindIndexBufferIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
}

void marshal_VkBindVertexBufferIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBindVertexBufferIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
}

void unmarshal_VkBindVertexBufferIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBindVertexBufferIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
}

void marshal_VkSetStateFlagsIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSetStateFlagsIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->data, sizeof(uint32_t));
}

void unmarshal_VkSetStateFlagsIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
                                                VkSetStateFlagsIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->data, sizeof(uint32_t));
}

void marshal_VkIndirectCommandsStreamNV(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkIndirectCommandsStreamNV* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}

void unmarshal_VkIndirectCommandsStreamNV(VulkanStream* vkStream, VkStructureType rootType,
                                          VkIndirectCommandsStreamNV* forUnmarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}

void marshal_VkIndirectCommandsLayoutTokenNV(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkIndirectCommandsLayoutTokenNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkIndirectCommandsTokenTypeNV*)&forMarshaling->tokenType,
                    sizeof(VkIndirectCommandsTokenTypeNV));
    vkStream->write((uint32_t*)&forMarshaling->stream, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vertexBindingUnit, sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->vertexDynamicStride, sizeof(VkBool32));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(
        &forMarshaling->pushconstantPipelineLayout, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkShaderStageFlags*)&forMarshaling->pushconstantShaderStageFlags,
                    sizeof(VkShaderStageFlags));
    vkStream->write((uint32_t*)&forMarshaling->pushconstantOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->pushconstantSize, sizeof(uint32_t));
    vkStream->write((VkIndirectStateFlagsNV*)&forMarshaling->indirectStateFlags,
                    sizeof(VkIndirectStateFlagsNV));
    vkStream->write((uint32_t*)&forMarshaling->indexTypeCount, sizeof(uint32_t));
    vkStream->write((const VkIndexType*)forMarshaling->pIndexTypes,
                    forMarshaling->indexTypeCount * sizeof(const VkIndexType));
    vkStream->write((const uint32_t*)forMarshaling->pIndexTypeValues,
                    forMarshaling->indexTypeCount * sizeof(const uint32_t));
}

void unmarshal_VkIndirectCommandsLayoutTokenNV(VulkanStream* vkStream, VkStructureType rootType,
                                               VkIndirectCommandsLayoutTokenNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkIndirectCommandsTokenTypeNV*)&forUnmarshaling->tokenType,
                   sizeof(VkIndirectCommandsTokenTypeNV));
    vkStream->read((uint32_t*)&forUnmarshaling->stream, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingUnit, sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->vertexDynamicStride, sizeof(VkBool32));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->pushconstantPipelineLayout, 1);
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->pushconstantShaderStageFlags,
                   sizeof(VkShaderStageFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->pushconstantOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->pushconstantSize, sizeof(uint32_t));
    vkStream->read((VkIndirectStateFlagsNV*)&forUnmarshaling->indirectStateFlags,
                   sizeof(VkIndirectStateFlagsNV));
    vkStream->read((uint32_t*)&forUnmarshaling->indexTypeCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pIndexTypes,
                    forUnmarshaling->indexTypeCount * sizeof(const VkIndexType));
    vkStream->read((VkIndexType*)forUnmarshaling->pIndexTypes,
                   forUnmarshaling->indexTypeCount * sizeof(const VkIndexType));
    vkStream->alloc((void**)&forUnmarshaling->pIndexTypeValues,
                    forUnmarshaling->indexTypeCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pIndexTypeValues,
                   forUnmarshaling->indexTypeCount * sizeof(const uint32_t));
}

void marshal_VkIndirectCommandsLayoutCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkIndirectCommandsLayoutUsageFlagsNV*)&forMarshaling->flags,
                    sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    vkStream->write((uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i) {
            marshal_VkIndirectCommandsLayoutTokenNV(
                vkStream, rootType,
                (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
    vkStream->write((const uint32_t*)forMarshaling->pStreamStrides,
                    forMarshaling->streamCount * sizeof(const uint32_t));
}

void unmarshal_VkIndirectCommandsLayoutCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkIndirectCommandsLayoutUsageFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    vkStream->read((uint32_t*)&forUnmarshaling->tokenCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pTokens,
                    forUnmarshaling->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i) {
            unmarshal_VkIndirectCommandsLayoutTokenNV(
                vkStream, rootType,
                (VkIndirectCommandsLayoutTokenNV*)(forUnmarshaling->pTokens + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->streamCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStreamStrides,
                    forUnmarshaling->streamCount * sizeof(const uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->pStreamStrides,
                   forUnmarshaling->streamCount * sizeof(const uint32_t));
}

void marshal_VkGeneratedCommandsInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkGeneratedCommandsInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(
        &forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i) {
            marshal_VkIndirectCommandsStreamNV(
                vkStream, rootType,
                (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->sequencesCount, sizeof(uint32_t));
    uint64_t cgen_var_2;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->preprocessBuffer,
                                                       &cgen_var_2, 1);
    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->preprocessOffset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->preprocessSize, sizeof(VkDeviceSize));
    uint64_t cgen_var_3;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer,
                                                       &cgen_var_3, 1);
    vkStream->write((uint64_t*)&cgen_var_3, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
    uint64_t cgen_var_4;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer,
                                                       &cgen_var_4, 1);
    vkStream->write((uint64_t*)&cgen_var_4, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}

void unmarshal_VkGeneratedCommandsInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                         VkGeneratedCommandsInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(
        &cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->streamCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStreams,
                    forUnmarshaling->streamCount * sizeof(const VkIndirectCommandsStreamNV));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->streamCount; ++i) {
            unmarshal_VkIndirectCommandsStreamNV(
                vkStream, rootType, (VkIndirectCommandsStreamNV*)(forUnmarshaling->pStreams + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->sequencesCount, sizeof(uint32_t));
    uint64_t cgen_var_2;
    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(
        &cgen_var_2, (VkBuffer*)&forUnmarshaling->preprocessBuffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->preprocessOffset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->preprocessSize, sizeof(VkDeviceSize));
    uint64_t cgen_var_3;
    vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(
        &cgen_var_3, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
    uint64_t cgen_var_4;
    vkStream->read((uint64_t*)&cgen_var_4, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(
        &cgen_var_4, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}

void marshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
                    sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(
        &forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
}

void unmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
                   sizeof(VkPipelineBindPoint));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(
        &cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
}

#endif
#ifdef VK_NV_inherited_viewport_scissor
void marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->inheritedViewportScissor2D, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->inheritedViewportScissor2D, sizeof(VkBool32));
}

void marshal_VkCommandBufferInheritanceViewportScissorInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->viewportScissor2D, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->viewportDepthCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportDepths;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pViewportDepths) {
        marshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewportDepths));
    }
}

void unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCommandBufferInheritanceViewportScissorInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->viewportScissor2D, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->viewportDepthCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pViewportDepths = (const VkViewport*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pViewportDepths) {
        vkStream->alloc((void**)&forUnmarshaling->pViewportDepths, sizeof(const VkViewport));
        unmarshal_VkViewport(vkStream, rootType, (VkViewport*)(forUnmarshaling->pViewportDepths));
    }
}

#endif
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->texelBufferAlignment, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->texelBufferAlignment, sizeof(VkBool32));
}

#endif
#ifdef VK_QCOM_render_pass_transform
void marshal_VkRenderPassTransformBeginInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassTransformBeginInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
}

void unmarshal_VkRenderPassTransformBeginInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassTransformBeginInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
}

void marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
}

void unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
}

#endif
#ifdef VK_EXT_device_memory_report
void marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->deviceMemoryReport, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->deviceMemoryReport, sizeof(VkBool32));
}

void marshal_VkDeviceMemoryReportCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceMemoryReportCallbackDataEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDeviceMemoryReportFlagsEXT));
    vkStream->write((VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type,
                    sizeof(VkDeviceMemoryReportEventTypeEXT));
    vkStream->write((uint64_t*)&forMarshaling->memoryObjectId, sizeof(uint64_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
    vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
}

void unmarshal_VkDeviceMemoryReportCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDeviceMemoryReportFlagsEXT));
    vkStream->read((VkDeviceMemoryReportEventTypeEXT*)&forUnmarshaling->type,
                   sizeof(VkDeviceMemoryReportEventTypeEXT));
    vkStream->read((uint64_t*)&forUnmarshaling->memoryObjectId, sizeof(uint64_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
    vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->heapIndex, sizeof(uint32_t));
}

void marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDeviceMemoryReportFlagsEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}

void unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDeviceMemoryReportFlagsEXT));
    forUnmarshaling->pfnUserCallback = (PFN_vkDeviceMemoryReportCallbackEXT)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
    vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}

#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess2, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess2, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->nullDescriptor, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess2, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess2, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->nullDescriptor, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->robustStorageBufferAccessSizeAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment,
                    sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->robustStorageBufferAccessSizeAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->robustUniformBufferAccessSizeAlignment,
                   sizeof(VkDeviceSize));
}

#endif
#ifdef VK_EXT_custom_border_color
void marshal_VkSamplerCustomBorderColorCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkClearColorValue(vkStream, rootType,
                              (VkClearColorValue*)(&forMarshaling->customBorderColor));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}

void unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkClearColorValue(vkStream, rootType,
                                (VkClearColorValue*)(&forUnmarshaling->customBorderColor));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}

void marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxCustomBorderColorSamplers, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxCustomBorderColorSamplers, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->customBorderColors, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->customBorderColorWithoutFormat, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->customBorderColors, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->customBorderColorWithoutFormat, sizeof(VkBool32));
}

#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_NV_present_barrier
void marshal_VkPhysicalDevicePresentBarrierFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentBarrierFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->presentBarrier, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePresentBarrierFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrier, sizeof(VkBool32));
}

void marshal_VkSurfaceCapabilitiesPresentBarrierNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSurfaceCapabilitiesPresentBarrierNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->presentBarrierSupported, sizeof(VkBool32));
}

void unmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSurfaceCapabilitiesPresentBarrierNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrierSupported, sizeof(VkBool32));
}

void marshal_VkSwapchainPresentBarrierCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSwapchainPresentBarrierCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->presentBarrierEnable, sizeof(VkBool32));
}

void unmarshal_VkSwapchainPresentBarrierCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSwapchainPresentBarrierCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrierEnable, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_private_data
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
#endif
#ifdef VK_NV_device_diagnostics_config
void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->diagnosticsConfig, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->diagnosticsConfig, sizeof(VkBool32));
}

void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags,
                    sizeof(VkDeviceDiagnosticsConfigFlagsNV));
}

void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkDeviceDiagnosticsConfigFlagsNV));
}

#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_low_latency
void marshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkQueryLowLatencySupportNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((void*)forMarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
}

void unmarshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
                                          VkQueryLowLatencySupportNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
    vkStream->read((void*)forUnmarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
}

#endif
#ifdef VK_EXT_metal_objects
void marshal_VkExportMetalObjectCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExportMetalObjectCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExportMetalObjectTypeFlagBitsEXT*)&forMarshaling->exportObjectType,
                    sizeof(VkExportMetalObjectTypeFlagBitsEXT));
}

void unmarshal_VkExportMetalObjectCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkExportMetalObjectCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExportMetalObjectTypeFlagBitsEXT*)&forUnmarshaling->exportObjectType,
                   sizeof(VkExportMetalObjectTypeFlagBitsEXT));
}

void marshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkExportMetalObjectsInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}

void unmarshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkExportMetalObjectsInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
}

void marshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkExportMetalDeviceInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((MTLDevice_id*)&forMarshaling->mtlDevice, sizeof(MTLDevice_id));
}

void unmarshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkExportMetalDeviceInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((MTLDevice_id*)&forUnmarshaling->mtlDevice, sizeof(MTLDevice_id));
}

void marshal_VkExportMetalCommandQueueInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkExportMetalCommandQueueInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkQueue_u64(&forMarshaling->queue, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((MTLCommandQueue_id*)&forMarshaling->mtlCommandQueue,
                    sizeof(MTLCommandQueue_id));
}

void unmarshal_VkExportMetalCommandQueueInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkExportMetalCommandQueueInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_0,
                                                      (VkQueue*)&forUnmarshaling->queue, 1);
    vkStream->read((MTLCommandQueue_id*)&forUnmarshaling->mtlCommandQueue,
                   sizeof(MTLCommandQueue_id));
}

void marshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkExportMetalBufferInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((MTLBuffer_id*)&forMarshaling->mtlBuffer, sizeof(MTLBuffer_id));
}

void unmarshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkExportMetalBufferInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, sizeof(MTLBuffer_id));
}

void marshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkImportMetalBufferInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((MTLBuffer_id*)&forMarshaling->mtlBuffer, sizeof(MTLBuffer_id));
}

void unmarshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkImportMetalBufferInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, sizeof(MTLBuffer_id));
}

void marshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkExportMetalTextureInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_1,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    uint64_t cgen_var_2;
    vkStream->handleMapping()->mapHandles_VkBufferView_u64(&forMarshaling->bufferView, &cgen_var_2,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->plane, sizeof(VkImageAspectFlagBits));
    vkStream->write((MTLTexture_id*)&forMarshaling->mtlTexture, sizeof(MTLTexture_id));
}

void unmarshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkExportMetalTextureInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_1, (VkImageView*)&forUnmarshaling->imageView, 1);
    uint64_t cgen_var_2;
    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBufferView(
        &cgen_var_2, (VkBufferView*)&forUnmarshaling->bufferView, 1);
    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->plane, sizeof(VkImageAspectFlagBits));
    vkStream->read((MTLTexture_id*)&forUnmarshaling->mtlTexture, sizeof(MTLTexture_id));
}

void marshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkImportMetalTextureInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->plane, sizeof(VkImageAspectFlagBits));
    vkStream->write((MTLTexture_id*)&forMarshaling->mtlTexture, sizeof(MTLTexture_id));
}

void unmarshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkImportMetalTextureInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->plane, sizeof(VkImageAspectFlagBits));
    vkStream->read((MTLTexture_id*)&forUnmarshaling->mtlTexture, sizeof(MTLTexture_id));
}

void marshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkExportMetalIOSurfaceInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((IOSurfaceRef*)&forMarshaling->ioSurface, sizeof(IOSurfaceRef));
}

void unmarshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkExportMetalIOSurfaceInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
    vkStream->read((IOSurfaceRef*)&forUnmarshaling->ioSurface, sizeof(IOSurfaceRef));
}

void marshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkImportMetalIOSurfaceInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((IOSurfaceRef*)&forMarshaling->ioSurface, sizeof(IOSurfaceRef));
}

void unmarshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkImportMetalIOSurfaceInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((IOSurfaceRef*)&forUnmarshaling->ioSurface, sizeof(IOSurfaceRef));
}

void marshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkExportMetalSharedEventInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkEvent_u64(&forMarshaling->event, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((MTLSharedEvent_id*)&forMarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
}

void unmarshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkExportMetalSharedEventInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_1,
                                                      (VkEvent*)&forUnmarshaling->event, 1);
    vkStream->read((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
}

void marshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkImportMetalSharedEventInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((MTLSharedEvent_id*)&forMarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
}

void unmarshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkImportMetalSharedEventInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
}

#endif
#ifdef VK_EXT_descriptor_buffer
void marshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->combinedImageSamplerDescriptorSingleArray,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bufferlessPushDescriptors, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->allowSamplerImageViewPostSubmitCreation,
                    sizeof(VkBool32));
    vkStream->write((VkDeviceSize*)&forMarshaling->descriptorBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorBufferBindings, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxResourceDescriptorBufferBindings,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxSamplerDescriptorBufferBindings,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxEmbeddedImmutableSamplerBindings,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxEmbeddedImmutableSamplers, sizeof(uint32_t));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->bufferCaptureReplayDescriptorDataSize;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->imageCaptureReplayDescriptorDataSize;
    vkStream->putBe64(cgen_var_1);
    uint64_t cgen_var_2 = (uint64_t)forMarshaling->imageViewCaptureReplayDescriptorDataSize;
    vkStream->putBe64(cgen_var_2);
    uint64_t cgen_var_3 = (uint64_t)forMarshaling->samplerCaptureReplayDescriptorDataSize;
    vkStream->putBe64(cgen_var_3);
    uint64_t cgen_var_4 =
        (uint64_t)forMarshaling->accelerationStructureCaptureReplayDescriptorDataSize;
    vkStream->putBe64(cgen_var_4);
    uint64_t cgen_var_5 = (uint64_t)forMarshaling->samplerDescriptorSize;
    vkStream->putBe64(cgen_var_5);
    uint64_t cgen_var_6 = (uint64_t)forMarshaling->combinedImageSamplerDescriptorSize;
    vkStream->putBe64(cgen_var_6);
    uint64_t cgen_var_7 = (uint64_t)forMarshaling->sampledImageDescriptorSize;
    vkStream->putBe64(cgen_var_7);
    uint64_t cgen_var_8 = (uint64_t)forMarshaling->storageImageDescriptorSize;
    vkStream->putBe64(cgen_var_8);
    uint64_t cgen_var_9 = (uint64_t)forMarshaling->uniformTexelBufferDescriptorSize;
    vkStream->putBe64(cgen_var_9);
    uint64_t cgen_var_10 = (uint64_t)forMarshaling->robustUniformTexelBufferDescriptorSize;
    vkStream->putBe64(cgen_var_10);
    uint64_t cgen_var_11 = (uint64_t)forMarshaling->storageTexelBufferDescriptorSize;
    vkStream->putBe64(cgen_var_11);
    uint64_t cgen_var_12 = (uint64_t)forMarshaling->robustStorageTexelBufferDescriptorSize;
    vkStream->putBe64(cgen_var_12);
    uint64_t cgen_var_13 = (uint64_t)forMarshaling->uniformBufferDescriptorSize;
    vkStream->putBe64(cgen_var_13);
    uint64_t cgen_var_14 = (uint64_t)forMarshaling->robustUniformBufferDescriptorSize;
    vkStream->putBe64(cgen_var_14);
    uint64_t cgen_var_15 = (uint64_t)forMarshaling->storageBufferDescriptorSize;
    vkStream->putBe64(cgen_var_15);
    uint64_t cgen_var_16 = (uint64_t)forMarshaling->robustStorageBufferDescriptorSize;
    vkStream->putBe64(cgen_var_16);
    uint64_t cgen_var_17 = (uint64_t)forMarshaling->inputAttachmentDescriptorSize;
    vkStream->putBe64(cgen_var_17);
    uint64_t cgen_var_18 = (uint64_t)forMarshaling->accelerationStructureDescriptorSize;
    vkStream->putBe64(cgen_var_18);
    vkStream->write((VkDeviceSize*)&forMarshaling->maxSamplerDescriptorBufferRange,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceDescriptorBufferRange,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->samplerDescriptorBufferAddressSpaceSize,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->resourceDescriptorBufferAddressSpaceSize,
                    sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->descriptorBufferAddressSpaceSize,
                    sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorBufferPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->combinedImageSamplerDescriptorSingleArray,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bufferlessPushDescriptors, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->allowSamplerImageViewPostSubmitCreation,
                   sizeof(VkBool32));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->descriptorBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorBufferBindings, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxResourceDescriptorBufferBindings,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSamplerDescriptorBufferBindings,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplerBindings,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplers, sizeof(uint32_t));
    forUnmarshaling->bufferCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
    forUnmarshaling->imageCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
    forUnmarshaling->imageViewCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
    forUnmarshaling->samplerCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
    forUnmarshaling->accelerationStructureCaptureReplayDescriptorDataSize =
        (size_t)vkStream->getBe64();
    forUnmarshaling->samplerDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->combinedImageSamplerDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->sampledImageDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->storageImageDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->uniformTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->robustUniformTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->storageTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->robustStorageTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->uniformBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->robustUniformBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->storageBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->robustStorageBufferDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->inputAttachmentDescriptorSize = (size_t)vkStream->getBe64();
    forUnmarshaling->accelerationStructureDescriptorSize = (size_t)vkStream->getBe64();
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxSamplerDescriptorBufferRange,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceDescriptorBufferRange,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->samplerDescriptorBufferAddressSpaceSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceDescriptorBufferAddressSpaceSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->descriptorBufferAddressSpaceSize,
                   sizeof(VkDeviceSize));
}

void marshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->combinedImageSamplerDensityMapDescriptorSize;
    vkStream->putBe64(cgen_var_0);
}

void unmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->combinedImageSamplerDensityMapDescriptorSize = (size_t)vkStream->getBe64();
}

void marshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->descriptorBuffer, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferCaptureReplay, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferImageLayoutIgnored,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferPushDescriptors, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorBufferFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBuffer, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferCaptureReplay, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferImageLayoutIgnored,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferPushDescriptors, sizeof(VkBool32));
}

void marshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDescriptorAddressInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceAddress*)&forMarshaling->address, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}

void unmarshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDescriptorAddressInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->address, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}

void marshal_VkDescriptorBufferBindingInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorBufferBindingInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceAddress*)&forMarshaling->address, sizeof(VkDeviceAddress));
    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
}

void unmarshal_VkDescriptorBufferBindingInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkDescriptorBufferBindingInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->address, sizeof(VkDeviceAddress));
    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
}

void marshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

void marshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
                                 const VkDescriptorDataEXT* forMarshaling) {
    (void)rootType;
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pSampler, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 8);
}

void unmarshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   VkDescriptorDataEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->alloc((void**)&forUnmarshaling->pSampler, sizeof(const VkSampler));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 8);
    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
                                                        (VkSampler*)forUnmarshaling->pSampler, 1);
}

void marshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkDescriptorGetInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
    marshal_VkDescriptorDataEXT(vkStream, rootType, (VkDescriptorDataEXT*)(&forMarshaling->data));
}

void unmarshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkDescriptorGetInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
    unmarshal_VkDescriptorDataEXT(vkStream, rootType,
                                  (VkDescriptorDataEXT*)(&forUnmarshaling->data));
}

void marshal_VkBufferCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCaptureDescriptorDataInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkBufferCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCaptureDescriptorDataInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
}

void marshal_VkImageCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageCaptureDescriptorDataInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkImageCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageCaptureDescriptorDataInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
                                                      (VkImage*)&forUnmarshaling->image, 1);
}

void marshal_VkImageViewCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageViewCaptureDescriptorDataInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageViewCaptureDescriptorDataInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkImageView(
        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
}

void marshal_VkSamplerCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerCaptureDescriptorDataInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSamplerCaptureDescriptorDataInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
                                                        (VkSampler*)&forUnmarshaling->sampler, 1);
}

void marshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const void*)forMarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
}

void unmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkOpaqueCaptureDescriptorDataCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
}

void marshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
        &forMarshaling->accelerationStructure, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
        &forMarshaling->accelerationStructureNV, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}

void unmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureCaptureDescriptorDataInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
        &cgen_var_1, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructureNV, 1);
}

#endif
#ifdef VK_EXT_graphics_pipeline_library
void marshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->graphicsPipelineLibrary, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->graphicsPipelineLibrary, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->graphicsPipelineLibraryFastLinking,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->graphicsPipelineLibraryIndependentInterpolationDecoration,
        sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->graphicsPipelineLibraryFastLinking,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->graphicsPipelineLibraryIndependentInterpolationDecoration,
        sizeof(VkBool32));
}

void marshal_VkGraphicsPipelineLibraryCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkGraphicsPipelineLibraryCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkGraphicsPipelineLibraryFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkGraphicsPipelineLibraryFlagsEXT));
}

void unmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkGraphicsPipelineLibraryCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkGraphicsPipelineLibraryFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkGraphicsPipelineLibraryFlagsEXT));
}

#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
void marshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderEarlyAndLateFragmentTests, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderEarlyAndLateFragmentTests, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_fragment_shading_rate_enums
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateEnums, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->supersampleFragmentShadingRates, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->noInvocationFragmentShadingRates, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateEnums, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->supersampleFragmentShadingRates, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->noInvocationFragmentShadingRates, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount,
                    sizeof(VkSampleCountFlagBits));
}

void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateInvocationCount,
                   sizeof(VkSampleCountFlagBits));
}

void marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFragmentShadingRateTypeNV*)&forMarshaling->shadingRateType,
                    sizeof(VkFragmentShadingRateTypeNV));
    vkStream->write((VkFragmentShadingRateNV*)&forMarshaling->shadingRate,
                    sizeof(VkFragmentShadingRateNV));
    vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
                    2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

void unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFragmentShadingRateTypeNV*)&forUnmarshaling->shadingRateType,
                   sizeof(VkFragmentShadingRateTypeNV));
    vkStream->read((VkFragmentShadingRateNV*)&forUnmarshaling->shadingRate,
                   sizeof(VkFragmentShadingRateNV));
    vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps,
                   2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}

#endif
#ifdef VK_NV_ray_tracing_motion_blur
void marshal_VkDeviceOrHostAddressConstKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkDeviceOrHostAddressConstKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void unmarshal_VkDeviceOrHostAddressConstKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkDeviceOrHostAddressConstKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
}

void unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryMotionTrianglesDataNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
}

void marshal_VkAccelerationStructureMotionInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureMotionInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxInstances, sizeof(uint32_t));
    vkStream->write((VkAccelerationStructureMotionInfoFlagsNV*)&forMarshaling->flags,
                    sizeof(VkAccelerationStructureMotionInfoFlagsNV));
}

void unmarshal_VkAccelerationStructureMotionInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureMotionInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxInstances, sizeof(uint32_t));
    vkStream->read((VkAccelerationStructureMotionInfoFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkAccelerationStructureMotionInfoFlagsNV));
}

void marshal_VkAccelerationStructureMatrixMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields {
        VkTransformMatrixKHR transformT0;
        VkTransformMatrixKHR transformT1;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields;

    const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forMarshaling_new =
        (const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forMarshaling);
    marshal_VkTransformMatrixKHR(vkStream, rootType,
                                 (VkTransformMatrixKHR*)(&forMarshaling_new->transformT0));
    marshal_VkTransformMatrixKHR(vkStream, rootType,
                                 (VkTransformMatrixKHR*)(&forMarshaling_new->transformT1));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
                    sizeof(uint64_t));
}

void unmarshal_VkAccelerationStructureMatrixMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureMatrixMotionInstanceNV* forUnmarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields {
        VkTransformMatrixKHR transformT0;
        VkTransformMatrixKHR transformT1;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields;

    VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forUnmarshaling_new =
        (VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
    unmarshal_VkTransformMatrixKHR(vkStream, rootType,
                                   (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT0));
    unmarshal_VkTransformMatrixKHR(vkStream, rootType,
                                   (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT1));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
                   sizeof(uint64_t));
}

void marshal_VkSRTDataNV(VulkanStream* vkStream, VkStructureType rootType,
                         const VkSRTDataNV* forMarshaling) {
    (void)rootType;
    vkStream->write((float*)&forMarshaling->sx, sizeof(float));
    vkStream->write((float*)&forMarshaling->a, sizeof(float));
    vkStream->write((float*)&forMarshaling->b, sizeof(float));
    vkStream->write((float*)&forMarshaling->pvx, sizeof(float));
    vkStream->write((float*)&forMarshaling->sy, sizeof(float));
    vkStream->write((float*)&forMarshaling->c, sizeof(float));
    vkStream->write((float*)&forMarshaling->pvy, sizeof(float));
    vkStream->write((float*)&forMarshaling->sz, sizeof(float));
    vkStream->write((float*)&forMarshaling->pvz, sizeof(float));
    vkStream->write((float*)&forMarshaling->qx, sizeof(float));
    vkStream->write((float*)&forMarshaling->qy, sizeof(float));
    vkStream->write((float*)&forMarshaling->qz, sizeof(float));
    vkStream->write((float*)&forMarshaling->qw, sizeof(float));
    vkStream->write((float*)&forMarshaling->tx, sizeof(float));
    vkStream->write((float*)&forMarshaling->ty, sizeof(float));
    vkStream->write((float*)&forMarshaling->tz, sizeof(float));
}

void unmarshal_VkSRTDataNV(VulkanStream* vkStream, VkStructureType rootType,
                           VkSRTDataNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((float*)&forUnmarshaling->sx, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->a, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->b, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->pvx, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->sy, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->c, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->pvy, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->sz, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->pvz, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->qx, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->qy, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->qz, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->qw, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->tx, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->ty, sizeof(float));
    vkStream->read((float*)&forUnmarshaling->tz, sizeof(float));
}

void marshal_VkAccelerationStructureSRTMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields {
        VkSRTDataNV transformT0;
        VkSRTDataNV transformT1;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields;

    const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forMarshaling_new =
        (const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forMarshaling);
    marshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT0));
    marshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT1));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
                    sizeof(uint64_t));
}

void unmarshal_VkAccelerationStructureSRTMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureSRTMotionInstanceNV* forUnmarshaling) {
    (void)rootType;

    typedef struct VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields {
        VkSRTDataNV transformT0;
        VkSRTDataNV transformT1;
        uint32_t dwords[2];
        uint64_t accelerationStructureReference;
    } VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields;

    VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forUnmarshaling_new =
        (VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
    unmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forUnmarshaling_new->transformT0));
    unmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forUnmarshaling_new->transformT1));
    for (uint32_t i = 0; i < 2; i++) {
        vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
    }
    vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
                   sizeof(uint64_t));
}

void marshal_VkAccelerationStructureMotionInstanceDataNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureMotionInstanceDataNV* forMarshaling) {
    (void)rootType;
    marshal_VkAccelerationStructureInstanceKHR(
        vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forMarshaling->staticInstance));
}

void unmarshal_VkAccelerationStructureMotionInstanceDataNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureMotionInstanceDataNV* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkAccelerationStructureInstanceKHR(
        vkStream, rootType,
        (VkAccelerationStructureInstanceKHR*)(&forUnmarshaling->staticInstance));
}

void marshal_VkAccelerationStructureMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureMotionInstanceNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkAccelerationStructureMotionInstanceTypeNV*)&forMarshaling->type,
                    sizeof(VkAccelerationStructureMotionInstanceTypeNV));
    vkStream->write((VkAccelerationStructureMotionInstanceFlagsNV*)&forMarshaling->flags,
                    sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
    marshal_VkAccelerationStructureMotionInstanceDataNV(
        vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forMarshaling->data));
}

void unmarshal_VkAccelerationStructureMotionInstanceNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureMotionInstanceNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkAccelerationStructureMotionInstanceTypeNV*)&forUnmarshaling->type,
                   sizeof(VkAccelerationStructureMotionInstanceTypeNV));
    vkStream->read((VkAccelerationStructureMotionInstanceFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
    unmarshal_VkAccelerationStructureMotionInstanceDataNV(
        vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forUnmarshaling->data));
}

void marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayTracingMotionBlur, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMotionBlur, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->ycbcr2plane444Formats, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->ycbcr2plane444Formats, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_fragment_density_map2
void marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapDeferred, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapDeferred, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->subsampledLoads, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->subsampledCoarseReconstructionEarlyAccess,
                    sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSubsampledSamplers,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->subsampledLoads, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->subsampledCoarseReconstructionEarlyAccess,
                   sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSubsampledSamplers,
                   sizeof(uint32_t));
}

#endif
#ifdef VK_QCOM_rotated_copy_commands
void marshal_VkCopyCommandTransformInfoQCOM(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkCopyCommandTransformInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
                    sizeof(VkSurfaceTransformFlagBitsKHR));
}

void unmarshal_VkCopyCommandTransformInfoQCOM(VulkanStream* vkStream, VkStructureType rootType,
                                              VkCopyCommandTransformInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
                   sizeof(VkSurfaceTransformFlagBitsKHR));
}

#endif
#ifdef VK_EXT_image_robustness
#endif
#ifdef VK_EXT_image_compression_control
void marshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->imageCompressionControl, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageCompressionControlFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->imageCompressionControl, sizeof(VkBool32));
}

void marshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkImageCompressionControlEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageCompressionFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkImageCompressionFlagsEXT));
    vkStream->write((uint32_t*)&forMarshaling->compressionControlPlaneCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pFixedRateFlags;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pFixedRateFlags) {
        vkStream->write((VkImageCompressionFixedRateFlagsEXT*)forMarshaling->pFixedRateFlags,
                        forMarshaling->compressionControlPlaneCount *
                            sizeof(VkImageCompressionFixedRateFlagsEXT));
    }
}

void unmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            VkImageCompressionControlEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageCompressionFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkImageCompressionFlagsEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->compressionControlPlaneCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pFixedRateFlags =
        (VkImageCompressionFixedRateFlagsEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pFixedRateFlags) {
        vkStream->alloc((void**)&forUnmarshaling->pFixedRateFlags,
                        forUnmarshaling->compressionControlPlaneCount *
                            sizeof(VkImageCompressionFixedRateFlagsEXT));
        vkStream->read((VkImageCompressionFixedRateFlagsEXT*)forUnmarshaling->pFixedRateFlags,
                       forUnmarshaling->compressionControlPlaneCount *
                           sizeof(VkImageCompressionFixedRateFlagsEXT));
    }
}

void marshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkSubresourceLayout2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkSubresourceLayout(vkStream, rootType,
                                (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
}

void unmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkSubresourceLayout2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkSubresourceLayout(vkStream, rootType,
                                  (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
}

void marshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkImageSubresource2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageSubresource(vkStream, rootType,
                               (VkImageSubresource*)(&forMarshaling->imageSubresource));
}

void unmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkImageSubresource2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageSubresource(vkStream, rootType,
                                 (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
}

void marshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkImageCompressionPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkImageCompressionFlagsEXT*)&forMarshaling->imageCompressionFlags,
                    sizeof(VkImageCompressionFlagsEXT));
    vkStream->write(
        (VkImageCompressionFixedRateFlagsEXT*)&forMarshaling->imageCompressionFixedRateFlags,
        sizeof(VkImageCompressionFixedRateFlagsEXT));
}

void unmarshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                               VkImageCompressionPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkImageCompressionFlagsEXT*)&forUnmarshaling->imageCompressionFlags,
                   sizeof(VkImageCompressionFlagsEXT));
    vkStream->read(
        (VkImageCompressionFixedRateFlagsEXT*)&forUnmarshaling->imageCompressionFixedRateFlags,
        sizeof(VkImageCompressionFixedRateFlagsEXT));
}

#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
void marshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->attachmentFeedbackLoopLayout, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopLayout, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_4444_formats
void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->formatA4R4G4B4, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->formatA4B4G4R4, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->formatA4R4G4B4, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->formatA4B4G4R4, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_device_fault
void marshal_VkPhysicalDeviceFaultFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFaultFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->deviceFault, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->deviceFaultVendorBinary, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFaultFeaturesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceFaultFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->deviceFault, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->deviceFaultVendorBinary, sizeof(VkBool32));
}

void marshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkDeviceFaultCountsEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->addressInfoCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vendorInfoCount, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->vendorBinarySize, sizeof(VkDeviceSize));
}

void unmarshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkDeviceFaultCountsEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->addressInfoCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vendorInfoCount, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->vendorBinarySize, sizeof(VkDeviceSize));
}

void marshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkDeviceFaultAddressInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceFaultAddressTypeEXT*)&forMarshaling->addressType,
                    sizeof(VkDeviceFaultAddressTypeEXT));
    vkStream->write((VkDeviceAddress*)&forMarshaling->reportedAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->addressPrecision, sizeof(VkDeviceSize));
}

void unmarshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkDeviceFaultAddressInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceFaultAddressTypeEXT*)&forUnmarshaling->addressType,
                   sizeof(VkDeviceFaultAddressTypeEXT));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->reportedAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->addressPrecision, sizeof(VkDeviceSize));
}

void marshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDeviceFaultVendorInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((uint64_t*)&forMarshaling->vendorFaultCode, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->vendorFaultData, sizeof(uint64_t));
}

void unmarshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDeviceFaultVendorInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((uint64_t*)&forUnmarshaling->vendorFaultCode, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->vendorFaultData, sizeof(uint64_t));
}

void marshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkDeviceFaultInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAddressInfos;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAddressInfos) {
        marshal_VkDeviceFaultAddressInfoEXT(
            vkStream, rootType, (VkDeviceFaultAddressInfoEXT*)(forMarshaling->pAddressInfos));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pVendorInfos;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pVendorInfos) {
        marshal_VkDeviceFaultVendorInfoEXT(
            vkStream, rootType, (VkDeviceFaultVendorInfoEXT*)(forMarshaling->pVendorInfos));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pVendorBinaryData;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pVendorBinaryData) {
        vkStream->write((void*)forMarshaling->pVendorBinaryData, sizeof(uint8_t));
    }
}

void unmarshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    VkDeviceFaultInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    // WARNING PTR CHECK
    forUnmarshaling->pAddressInfos = (VkDeviceFaultAddressInfoEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAddressInfos) {
        vkStream->alloc((void**)&forUnmarshaling->pAddressInfos,
                        sizeof(VkDeviceFaultAddressInfoEXT));
        unmarshal_VkDeviceFaultAddressInfoEXT(
            vkStream, rootType, (VkDeviceFaultAddressInfoEXT*)(forUnmarshaling->pAddressInfos));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pVendorInfos = (VkDeviceFaultVendorInfoEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pVendorInfos) {
        vkStream->alloc((void**)&forUnmarshaling->pVendorInfos, sizeof(VkDeviceFaultVendorInfoEXT));
        unmarshal_VkDeviceFaultVendorInfoEXT(
            vkStream, rootType, (VkDeviceFaultVendorInfoEXT*)(forUnmarshaling->pVendorInfos));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pVendorBinaryData = (void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pVendorBinaryData) {
        vkStream->alloc((void**)&forUnmarshaling->pVendorBinaryData, sizeof(uint8_t));
        vkStream->read((void*)forUnmarshaling->pVendorBinaryData, sizeof(uint8_t));
    }
}

void marshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
    vkStream->write((VkDeviceFaultVendorBinaryHeaderVersionEXT*)&forMarshaling->headerVersion,
                    sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT));
    vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
    vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint32_t*)&forMarshaling->applicationNameOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->engineNameOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
}

void unmarshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->headerSize, sizeof(uint32_t));
    vkStream->read((VkDeviceFaultVendorBinaryHeaderVersionEXT*)&forUnmarshaling->headerVersion,
                   sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT));
    vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
    vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint32_t*)&forUnmarshaling->applicationNameOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->engineNameOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
}

#endif
#ifdef VK_ARM_rasterization_order_attachment_access
void marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderColorAttachmentAccess,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderDepthAttachmentAccess,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderStencilAttachmentAccess,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderColorAttachmentAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderDepthAttachmentAccess,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderStencilAttachmentAccess,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_rgba10x6_formats
void marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->formatRgba10x6WithoutYCbCrSampler, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->formatRgba10x6WithoutYCbCrSampler,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
void marshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkDirectFBSurfaceCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDirectFBSurfaceCreateFlagsEXT));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dfb;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->dfb) {
        vkStream->write((IDirectFB*)forMarshaling->dfb, sizeof(IDirectFB));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->surface;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->surface) {
        vkStream->write((IDirectFBSurface*)forMarshaling->surface, sizeof(IDirectFBSurface));
    }
}

void unmarshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDirectFBSurfaceCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDirectFBSurfaceCreateFlagsEXT));
    // WARNING PTR CHECK
    forUnmarshaling->dfb = (IDirectFB*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->dfb) {
        vkStream->alloc((void**)&forUnmarshaling->dfb, sizeof(IDirectFB));
        vkStream->read((IDirectFB*)forUnmarshaling->dfb, sizeof(IDirectFB));
    }
    // WARNING PTR CHECK
    forUnmarshaling->surface = (IDirectFBSurface*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->surface) {
        vkStream->alloc((void**)&forUnmarshaling->surface, sizeof(IDirectFBSurface));
        vkStream->read((IDirectFBSurface*)forUnmarshaling->surface, sizeof(IDirectFBSurface));
    }
}

#endif
#ifdef VK_VALVE_mutable_descriptor_type
void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->mutableDescriptorType, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->mutableDescriptorType, sizeof(VkBool32));
}

void marshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkMutableDescriptorTypeListEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->descriptorTypeCount, sizeof(uint32_t));
    vkStream->write((const VkDescriptorType*)forMarshaling->pDescriptorTypes,
                    forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
}

void unmarshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkMutableDescriptorTypeListEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorTypeCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDescriptorTypes,
                    forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
    vkStream->read((VkDescriptorType*)forUnmarshaling->pDescriptorTypes,
                   forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
}

void marshal_VkMutableDescriptorTypeCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMutableDescriptorTypeCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i) {
            marshal_VkMutableDescriptorTypeListEXT(
                vkStream, rootType,
                (const VkMutableDescriptorTypeListEXT*)(forMarshaling->pMutableDescriptorTypeLists +
                                                        i));
        }
    }
}

void unmarshal_VkMutableDescriptorTypeCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMutableDescriptorTypeCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pMutableDescriptorTypeLists,
                    forUnmarshaling->mutableDescriptorTypeListCount *
                        sizeof(const VkMutableDescriptorTypeListEXT));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mutableDescriptorTypeListCount; ++i) {
            unmarshal_VkMutableDescriptorTypeListEXT(
                vkStream, rootType,
                (VkMutableDescriptorTypeListEXT*)(forUnmarshaling->pMutableDescriptorTypeLists +
                                                  i));
        }
    }
}

#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->vertexInputDynamicState, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->vertexInputDynamicState, sizeof(VkBool32));
}

void marshal_VkVertexInputBindingDescription2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVertexInputBindingDescription2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
    vkStream->write((VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
    vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
}

void unmarshal_VkVertexInputBindingDescription2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVertexInputBindingDescription2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
    vkStream->read((VkVertexInputRate*)&forUnmarshaling->inputRate, sizeof(VkVertexInputRate));
    vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
}

void marshal_VkVertexInputAttributeDescription2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkVertexInputAttributeDescription2EXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->location, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
}

void unmarshal_VkVertexInputAttributeDescription2EXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkVertexInputAttributeDescription2EXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->location, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
}

#endif
#ifdef VK_EXT_physical_device_drm
void marshal_VkPhysicalDeviceDrmPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->hasPrimary, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->hasRender, sizeof(VkBool32));
    vkStream->write((int64_t*)&forMarshaling->primaryMajor, sizeof(int64_t));
    vkStream->write((int64_t*)&forMarshaling->primaryMinor, sizeof(int64_t));
    vkStream->write((int64_t*)&forMarshaling->renderMajor, sizeof(int64_t));
    vkStream->write((int64_t*)&forMarshaling->renderMinor, sizeof(int64_t));
}

void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->hasPrimary, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->hasRender, sizeof(VkBool32));
    vkStream->read((int64_t*)&forUnmarshaling->primaryMajor, sizeof(int64_t));
    vkStream->read((int64_t*)&forUnmarshaling->primaryMinor, sizeof(int64_t));
    vkStream->read((int64_t*)&forUnmarshaling->renderMajor, sizeof(int64_t));
    vkStream->read((int64_t*)&forUnmarshaling->renderMinor, sizeof(int64_t));
}

#endif
#ifdef VK_EXT_device_address_binding_report
void marshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->reportAddressBinding, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAddressBindingReportFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->reportAddressBinding, sizeof(VkBool32));
}

void marshal_VkDeviceAddressBindingCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDeviceAddressBindingCallbackDataEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceAddressBindingFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkDeviceAddressBindingFlagsEXT));
    vkStream->write((VkDeviceAddress*)&forMarshaling->baseAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceAddressBindingTypeEXT*)&forMarshaling->bindingType,
                    sizeof(VkDeviceAddressBindingTypeEXT));
}

void unmarshal_VkDeviceAddressBindingCallbackDataEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDeviceAddressBindingCallbackDataEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceAddressBindingFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkDeviceAddressBindingFlagsEXT));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->baseAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceAddressBindingTypeEXT*)&forUnmarshaling->bindingType,
                   sizeof(VkDeviceAddressBindingTypeEXT));
}

#endif
#ifdef VK_EXT_depth_clip_control
void marshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthClipControlFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->depthClipControl, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDepthClipControlFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->depthClipControl, sizeof(VkBool32));
}

void marshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineViewportDepthClipControlCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->negativeOneToOne, sizeof(VkBool32));
}

void unmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineViewportDepthClipControlCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->negativeOneToOne, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_primitive_topology_list_restart
void marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->primitiveTopologyListRestart, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->primitiveTopologyPatchListRestart, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveTopologyListRestart, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveTopologyPatchListRestart,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_FUCHSIA_external_memory
void marshal_VkImportMemoryZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->write((zx_handle_t*)&forMarshaling->handle, sizeof(zx_handle_t));
}

void unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImportMemoryZirconHandleInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
    vkStream->read((zx_handle_t*)&forUnmarshaling->handle, sizeof(zx_handle_t));
}

void marshal_VkMemoryZirconHandlePropertiesFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}

void unmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMemoryZirconHandlePropertiesFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}

void marshal_VkMemoryGetZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMemoryGetZirconHandleInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

#endif
#ifdef VK_FUCHSIA_external_semaphore
void marshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->write((zx_handle_t*)&forMarshaling->zirconHandle, sizeof(zx_handle_t));
}

void unmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImportSemaphoreZirconHandleInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
                   sizeof(VkSemaphoreImportFlags));
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    vkStream->read((zx_handle_t*)&forUnmarshaling->zirconHandle, sizeof(zx_handle_t));
}

void marshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
                                                          1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

void unmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSemaphoreGetZirconHandleInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}

#endif
#ifdef VK_FUCHSIA_buffer_collection
void marshal_VkBufferCollectionCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((zx_handle_t*)&forMarshaling->collectionToken, sizeof(zx_handle_t));
}

void unmarshal_VkBufferCollectionCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCollectionCreateInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((zx_handle_t*)&forUnmarshaling->collectionToken, sizeof(zx_handle_t));
}

void marshal_VkImportMemoryBufferCollectionFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->collection;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->index, sizeof(uint32_t));
}

void unmarshal_VkImportMemoryBufferCollectionFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImportMemoryBufferCollectionFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->collection = (VkBufferCollectionFUCHSIA)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->index, sizeof(uint32_t));
}

void marshal_VkBufferCollectionImageCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->collection;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->index, sizeof(uint32_t));
}

void unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCollectionImageCreateInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->collection = (VkBufferCollectionFUCHSIA)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->index, sizeof(uint32_t));
}

void marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->minBufferCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxBufferCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minBufferCountForCamping, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minBufferCountForDedicatedSlack, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minBufferCountForSharedSlack, sizeof(uint32_t));
}

void unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCollectionConstraintsInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->minBufferCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxBufferCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minBufferCountForCamping, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minBufferCountForDedicatedSlack, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minBufferCountForSharedSlack, sizeof(uint32_t));
}

void marshal_VkBufferConstraintsInfoFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkBufferConstraintsInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkBufferCreateInfo(vkStream, rootType,
                               (VkBufferCreateInfo*)(&forMarshaling->createInfo));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
                    sizeof(VkFormatFeatureFlags));
    marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
        vkStream, rootType,
        (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
}

void unmarshal_VkBufferConstraintsInfoFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                              VkBufferConstraintsInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkBufferCreateInfo(vkStream, rootType,
                                 (VkBufferCreateInfo*)(&forUnmarshaling->createInfo));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures,
                   sizeof(VkFormatFeatureFlags));
    unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
        vkStream, rootType,
        (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
}

void marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->collection;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->index, sizeof(uint32_t));
}

void unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCollectionBufferCreateInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->collection = (VkBufferCollectionFUCHSIA)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->index, sizeof(uint32_t));
}

void marshal_VkSysmemColorSpaceFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSysmemColorSpaceFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->colorSpace, sizeof(uint32_t));
}

void unmarshal_VkSysmemColorSpaceFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                         VkSysmemColorSpaceFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->colorSpace, sizeof(uint32_t));
}

void marshal_VkBufferCollectionPropertiesFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkBufferCollectionPropertiesFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->bufferCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->createInfoIndex, sizeof(uint32_t));
    vkStream->write((uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
                    sizeof(VkFormatFeatureFlags));
    marshal_VkSysmemColorSpaceFUCHSIA(
        vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forMarshaling->sysmemColorSpaceIndex));
    marshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
                    sizeof(VkSamplerYcbcrModelConversion));
    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
                    sizeof(VkSamplerYcbcrRange));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
                    sizeof(VkChromaLocation));
    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
                    sizeof(VkChromaLocation));
}

void unmarshal_VkBufferCollectionPropertiesFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkBufferCollectionPropertiesFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->createInfoIndex, sizeof(uint32_t));
    vkStream->read((uint64_t*)&forUnmarshaling->sysmemPixelFormat, sizeof(uint64_t));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures,
                   sizeof(VkFormatFeatureFlags));
    unmarshal_VkSysmemColorSpaceFUCHSIA(
        vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forUnmarshaling->sysmemColorSpaceIndex));
    unmarshal_VkComponentMapping(
        vkStream, rootType,
        (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
                   sizeof(VkSamplerYcbcrModelConversion));
    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
                   sizeof(VkSamplerYcbcrRange));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
                   sizeof(VkChromaLocation));
    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
                   sizeof(VkChromaLocation));
}

void marshal_VkImageFormatConstraintsInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkImageCreateInfo(vkStream, rootType,
                              (VkImageCreateInfo*)(&forMarshaling->imageCreateInfo));
    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
                    sizeof(VkFormatFeatureFlags));
    vkStream->write((VkImageFormatConstraintsFlagsFUCHSIA*)&forMarshaling->flags,
                    sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
    vkStream->write((uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->colorSpaceCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorSpaceCount; ++i) {
            marshal_VkSysmemColorSpaceFUCHSIA(
                vkStream, rootType,
                (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces + i));
        }
    }
}

void unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageFormatConstraintsInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkImageCreateInfo(vkStream, rootType,
                                (VkImageCreateInfo*)(&forUnmarshaling->imageCreateInfo));
    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures,
                   sizeof(VkFormatFeatureFlags));
    vkStream->read((VkImageFormatConstraintsFlagsFUCHSIA*)&forUnmarshaling->flags,
                   sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
    vkStream->read((uint64_t*)&forUnmarshaling->sysmemPixelFormat, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->colorSpaceCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pColorSpaces,
                    forUnmarshaling->colorSpaceCount * sizeof(const VkSysmemColorSpaceFUCHSIA));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorSpaceCount; ++i) {
            unmarshal_VkSysmemColorSpaceFUCHSIA(
                vkStream, rootType,
                (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces + i));
        }
    }
}

void marshal_VkImageConstraintsInfoFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkImageConstraintsInfoFUCHSIA* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->formatConstraintsCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->formatConstraintsCount; ++i) {
            marshal_VkImageFormatConstraintsInfoFUCHSIA(
                vkStream, rootType,
                (const VkImageFormatConstraintsInfoFUCHSIA*)(forMarshaling->pFormatConstraints +
                                                             i));
        }
    }
    marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
        vkStream, rootType,
        (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
    vkStream->write((VkImageConstraintsInfoFlagsFUCHSIA*)&forMarshaling->flags,
                    sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
}

void unmarshal_VkImageConstraintsInfoFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
                                             VkImageConstraintsInfoFUCHSIA* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->formatConstraintsCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pFormatConstraints,
                    forUnmarshaling->formatConstraintsCount *
                        sizeof(const VkImageFormatConstraintsInfoFUCHSIA));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->formatConstraintsCount; ++i) {
            unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
                vkStream, rootType,
                (VkImageFormatConstraintsInfoFUCHSIA*)(forUnmarshaling->pFormatConstraints + i));
        }
    }
    unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
        vkStream, rootType,
        (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
    vkStream->read((VkImageConstraintsInfoFlagsFUCHSIA*)&forUnmarshaling->flags,
                   sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
}

#endif
#ifdef VK_HUAWEI_subpass_shading
void marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
                                                           1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
}

void unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSubpassShadingPipelineCreateInfoHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
        &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->subpassShading, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->subpassShading, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxSubpassShadingWorkgroupSizeAspectRatio,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxSubpassShadingWorkgroupSizeAspectRatio,
                   sizeof(uint32_t));
}

#endif
#ifdef VK_HUAWEI_invocation_mask
void marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->invocationMask, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->invocationMask, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_external_memory_rdma
void marshal_VkMemoryGetRemoteAddressInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkMemoryGetRemoteAddressInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
                                                             1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
                    sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void unmarshal_VkMemoryGetRemoteAddressInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                              VkMemoryGetRemoteAddressInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
                   sizeof(VkExternalMemoryHandleTypeFlagBits));
}

void marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->externalMemoryRDMA, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->externalMemoryRDMA, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_pipeline_properties
void marshal_VkPipelinePropertiesIdentifierEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelinePropertiesIdentifierEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint8_t*)forMarshaling->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t));
}

void unmarshal_VkPipelinePropertiesIdentifierEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelinePropertiesIdentifierEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint8_t*)forUnmarshaling->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t));
}

void marshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelinePropertiesIdentifier, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelinePropertiesFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelinePropertiesIdentifier, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
void marshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multisampledRenderToSingleSampled, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampled,
                   sizeof(VkBool32));
}

void marshal_VkSubpassResolvePerformanceQueryEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSubpassResolvePerformanceQueryEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->optimal, sizeof(VkBool32));
}

void unmarshal_VkSubpassResolvePerformanceQueryEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSubpassResolvePerformanceQueryEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->optimal, sizeof(VkBool32));
}

void marshal_VkMultisampledRenderToSingleSampledInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMultisampledRenderToSingleSampledInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multisampledRenderToSingleSampledEnable,
                    sizeof(VkBool32));
    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
                    sizeof(VkSampleCountFlagBits));
}

void unmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMultisampledRenderToSingleSampledInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampledEnable,
                   sizeof(VkBool32));
    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
                   sizeof(VkSampleCountFlagBits));
}

#endif
#ifdef VK_EXT_extended_dynamic_state2
void marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2LogicOp, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2PatchControlPoints,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2LogicOp, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2PatchControlPoints,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_QNX_screen_surface
void marshal_VkScreenSurfaceCreateInfoQNX(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkScreenSurfaceCreateInfoQNX* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkScreenSurfaceCreateFlagsQNX*)&forMarshaling->flags,
                    sizeof(VkScreenSurfaceCreateFlagsQNX));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->context;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->context) {
        vkStream->write((_screen_context*)forMarshaling->context, sizeof(_screen_context));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->window;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->window) {
        vkStream->write((_screen_window*)forMarshaling->window, sizeof(_screen_window));
    }
}

void unmarshal_VkScreenSurfaceCreateInfoQNX(VulkanStream* vkStream, VkStructureType rootType,
                                            VkScreenSurfaceCreateInfoQNX* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkScreenSurfaceCreateFlagsQNX*)&forUnmarshaling->flags,
                   sizeof(VkScreenSurfaceCreateFlagsQNX));
    // WARNING PTR CHECK
    forUnmarshaling->context = (_screen_context*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->context) {
        vkStream->alloc((void**)&forUnmarshaling->context, sizeof(_screen_context));
        vkStream->read((_screen_context*)forUnmarshaling->context, sizeof(_screen_context));
    }
    // WARNING PTR CHECK
    forUnmarshaling->window = (_screen_window*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->window) {
        vkStream->alloc((void**)&forUnmarshaling->window, sizeof(_screen_window));
        vkStream->read((_screen_window*)forUnmarshaling->window, sizeof(_screen_window));
    }
}

#endif
#ifdef VK_EXT_color_write_enable
void marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->colorWriteEnable, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceColorWriteEnableFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->colorWriteEnable, sizeof(VkBool32));
}

void marshal_VkPipelineColorWriteCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineColorWriteCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->write((const VkBool32*)forMarshaling->pColorWriteEnables,
                    forMarshaling->attachmentCount * sizeof(const VkBool32));
}

void unmarshal_VkPipelineColorWriteCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineColorWriteCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pColorWriteEnables,
                    forUnmarshaling->attachmentCount * sizeof(const VkBool32));
    vkStream->read((VkBool32*)forUnmarshaling->pColorWriteEnables,
                   forUnmarshaling->attachmentCount * sizeof(const VkBool32));
}

#endif
#ifdef VK_EXT_primitives_generated_query
void marshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQuery, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQueryWithRasterizerDiscard,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQueryWithNonZeroStreams,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQuery, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithRasterizerDiscard,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithNonZeroStreams,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_GOOGLE_gfxstream
void marshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkImportColorBufferGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
}

void unmarshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                         VkImportColorBufferGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->colorBuffer, sizeof(uint32_t));
}

void marshal_VkImportBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkImportBufferGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
}

void unmarshal_VkImportBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                    VkImportBufferGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->buffer, sizeof(uint32_t));
}

void marshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                const VkCreateBlobGOOGLE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->blobMem, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->blobFlags, sizeof(uint32_t));
    vkStream->write((uint64_t*)&forMarshaling->blobId, sizeof(uint64_t));
}

void unmarshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                  VkCreateBlobGOOGLE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    forUnmarshaling->sType = VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE;
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->blobMem, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->blobFlags, sizeof(uint32_t));
    vkStream->read((uint64_t*)&forUnmarshaling->blobId, sizeof(uint64_t));
}

#endif
#ifdef VK_EXT_global_priority_query
#endif
#ifdef VK_EXT_image_view_min_lod
void marshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->minLod, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageViewMinLodFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->minLod, sizeof(VkBool32));
}

void marshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkImageViewMinLodCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((float*)&forMarshaling->minLod, sizeof(float));
}

void unmarshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkImageViewMinLodCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((float*)&forUnmarshaling->minLod, sizeof(float));
}

#endif
#ifdef VK_EXT_multi_draw
void marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multiDraw, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiDrawFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multiDraw, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxMultiDrawCount, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiDrawPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiDrawCount, sizeof(uint32_t));
}

void marshal_VkMultiDrawInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                const VkMultiDrawInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
}

void unmarshal_VkMultiDrawInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  VkMultiDrawInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
}

void marshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkMultiDrawIndexedInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
    vkStream->write((int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
}

void unmarshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         VkMultiDrawIndexedInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->firstIndex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
    vkStream->read((int32_t*)&forUnmarshaling->vertexOffset, sizeof(int32_t));
}

#endif
#ifdef VK_EXT_image_2d_view_of_3d
void marshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->image2DViewOf3D, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->sampler2DViewOf3D, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->image2DViewOf3D, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->sampler2DViewOf3D, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_shader_tile_image
void marshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderTileImageFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageColorReadAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageDepthReadAccess, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageStencilReadAccess, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderTileImageFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageColorReadAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageDepthReadAccess, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageStencilReadAccess, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderTileImagePropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageCoherentReadAccelerated,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageReadSampleFromPixelRateInvocation,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageReadFromHelperInvocation,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderTileImagePropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageCoherentReadAccelerated,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageReadSampleFromPixelRateInvocation,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageReadFromHelperInvocation,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_opacity_micromap
void marshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
                                const VkMicromapUsageEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->count, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->subdivisionLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->format, sizeof(uint32_t));
}

void unmarshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
                                  VkMicromapUsageEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->count, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->subdivisionLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->format, sizeof(uint32_t));
}

void marshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkDeviceOrHostAddressKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void unmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
                                        VkDeviceOrHostAddressKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void marshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkMicromapBuildInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMicromapTypeEXT*)&forMarshaling->type, sizeof(VkMicromapTypeEXT));
    vkStream->write((VkBuildMicromapFlagsEXT*)&forMarshaling->flags,
                    sizeof(VkBuildMicromapFlagsEXT));
    vkStream->write((VkBuildMicromapModeEXT*)&forMarshaling->mode, sizeof(VkBuildMicromapModeEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dstMicromap;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pUsageCounts) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
                marshal_VkMicromapUsageEXT(
                    vkStream, rootType,
                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
            }
        }
    }
    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->triangleArray));
    vkStream->write((VkDeviceSize*)&forMarshaling->triangleArrayStride, sizeof(VkDeviceSize));
}

void unmarshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      VkMicromapBuildInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMicromapTypeEXT*)&forUnmarshaling->type, sizeof(VkMicromapTypeEXT));
    vkStream->read((VkBuildMicromapFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkBuildMicromapFlagsEXT));
    vkStream->read((VkBuildMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkBuildMicromapModeEXT));
    forUnmarshaling->dstMicromap = (VkMicromapEXT)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUsageCounts) {
        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
                unmarshal_VkMicromapUsageEXT(
                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
            }
        }
    }
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->triangleArray));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->triangleArrayStride, sizeof(VkDeviceSize));
}

void marshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkMicromapCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMicromapCreateFlagsEXT*)&forMarshaling->createFlags,
                    sizeof(VkMicromapCreateFlagsEXT));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkMicromapTypeEXT*)&forMarshaling->type, sizeof(VkMicromapTypeEXT));
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void unmarshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkMicromapCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMicromapCreateFlagsEXT*)&forUnmarshaling->createFlags,
                   sizeof(VkMicromapCreateFlagsEXT));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkMicromapTypeEXT*)&forUnmarshaling->type, sizeof(VkMicromapTypeEXT));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void marshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->micromap, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->micromapCaptureReplay, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->micromapHostCommands, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceOpacityMicromapFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->micromap, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->micromapCaptureReplay, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->micromapHostCommands, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxOpacity2StateSubdivisionLevel, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxOpacity4StateSubdivisionLevel, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceOpacityMicromapPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxOpacity2StateSubdivisionLevel, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxOpacity4StateSubdivisionLevel, sizeof(uint32_t));
}

void marshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                      const VkMicromapVersionInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const uint8_t*)forMarshaling->pVersionData,
                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
}

void unmarshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                        VkMicromapVersionInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pVersionData,
                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->pVersionData,
                   2 * VK_UUID_SIZE * sizeof(const uint8_t));
}

void marshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkCopyMicromapToMemoryInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->src;
    vkStream->putBe64(cgen_var_0);
    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void unmarshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkCopyMicromapToMemoryInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->src = (VkMicromapEXT)vkStream->getBe64();
    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void marshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkCopyMemoryToMicromapInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dst;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void unmarshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkCopyMemoryToMicromapInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
    forUnmarshaling->dst = (VkMicromapEXT)vkStream->getBe64();
    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void marshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkCopyMicromapInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->src;
    vkStream->putBe64(cgen_var_0);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->dst;
    vkStream->putBe64(cgen_var_1);
    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void unmarshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     VkCopyMicromapInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->src = (VkMicromapEXT)vkStream->getBe64();
    forUnmarshaling->dst = (VkMicromapEXT)vkStream->getBe64();
    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
}

void marshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkMicromapBuildSizesInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->micromapSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->buildScratchSize, sizeof(VkDeviceSize));
    vkStream->write((VkBool32*)&forMarshaling->discardable, sizeof(VkBool32));
}

void unmarshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkMicromapBuildSizesInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->micromapSize, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->buildScratchSize, sizeof(VkDeviceSize));
    vkStream->read((VkBool32*)&forUnmarshaling->discardable, sizeof(VkBool32));
}

void marshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureTrianglesOpacityMicromapEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexBuffer));
    vkStream->write((VkDeviceSize*)&forMarshaling->indexStride, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->baseTriangle, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pUsageCounts) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
                marshal_VkMicromapUsageEXT(
                    vkStream, rootType,
                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
            }
        }
    }
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->micromap;
    vkStream->putBe64(cgen_var_1);
}

void unmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureTrianglesOpacityMicromapEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->indexStride, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->baseTriangle, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUsageCounts) {
        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
                unmarshal_VkMicromapUsageEXT(
                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
            }
        }
    }
    forUnmarshaling->micromap = (VkMicromapEXT)vkStream->getBe64();
}

void marshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkMicromapTriangleEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->dataOffset, sizeof(uint32_t));
    vkStream->write((uint16_t*)&forMarshaling->subdivisionLevel, sizeof(uint16_t));
    vkStream->write((uint16_t*)&forMarshaling->format, sizeof(uint16_t));
}

void unmarshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     VkMicromapTriangleEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->dataOffset, sizeof(uint32_t));
    vkStream->read((uint16_t*)&forUnmarshaling->subdivisionLevel, sizeof(uint16_t));
    vkStream->read((uint16_t*)&forUnmarshaling->format, sizeof(uint16_t));
}

#endif
#ifdef VK_NV_displacement_micromap
void marshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->displacementMicromap, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDisplacementMicromapFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->displacementMicromap, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxDisplacementMicromapSubdivisionLevel,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDisplacementMicromapPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxDisplacementMicromapSubdivisionLevel,
                   sizeof(uint32_t));
}

void marshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureTrianglesDisplacementMicromapNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->displacementBiasAndScaleFormat, sizeof(VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->displacementVectorFormat, sizeof(VkFormat));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacementBiasAndScaleBuffer));
    vkStream->write((VkDeviceSize*)&forMarshaling->displacementBiasAndScaleStride,
                    sizeof(VkDeviceSize));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacementVectorBuffer));
    vkStream->write((VkDeviceSize*)&forMarshaling->displacementVectorStride, sizeof(VkDeviceSize));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacedMicromapPrimitiveFlags));
    vkStream->write((VkDeviceSize*)&forMarshaling->displacedMicromapPrimitiveFlagsStride,
                    sizeof(VkDeviceSize));
    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexBuffer));
    vkStream->write((VkDeviceSize*)&forMarshaling->indexStride, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->baseTriangle, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pUsageCounts) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
                marshal_VkMicromapUsageEXT(
                    vkStream, rootType,
                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
            }
        }
    }
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->micromap;
    vkStream->putBe64(cgen_var_1);
}

void unmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureTrianglesDisplacementMicromapNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->displacementBiasAndScaleFormat, sizeof(VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->displacementVectorFormat, sizeof(VkFormat));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementBiasAndScaleBuffer));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacementBiasAndScaleStride,
                   sizeof(VkDeviceSize));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementVectorBuffer));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacementVectorStride, sizeof(VkDeviceSize));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType,
        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacedMicromapPrimitiveFlags));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacedMicromapPrimitiveFlagsStride,
                   sizeof(VkDeviceSize));
    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->indexStride, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->baseTriangle, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pUsageCounts) {
        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
                unmarshal_VkMicromapUsageEXT(
                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
            }
        }
    }
    forUnmarshaling->micromap = (VkMicromapEXT)vkStream->getBe64();
}

#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
void marshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->clustercullingShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewClusterCullingShader, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->clustercullingShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewClusterCullingShader, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)forMarshaling->maxWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxOutputClusterCount, sizeof(uint32_t));
    vkStream->write((VkDeviceSize*)&forMarshaling->indirectBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
}

void unmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)forUnmarshaling->maxWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxOutputClusterCount, sizeof(uint32_t));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->indirectBufferOffsetAlignment,
                   sizeof(VkDeviceSize));
}

#endif
#ifdef VK_EXT_border_color_swizzle
void marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->borderColorSwizzle, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->borderColorSwizzleFromImage, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->borderColorSwizzle, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->borderColorSwizzleFromImage, sizeof(VkBool32));
}

void marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkComponentMapping(vkStream, rootType,
                               (VkComponentMapping*)(&forMarshaling->components));
    vkStream->write((VkBool32*)&forMarshaling->srgb, sizeof(VkBool32));
}

void unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSamplerBorderColorComponentMappingCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkComponentMapping(vkStream, rootType,
                                 (VkComponentMapping*)(&forUnmarshaling->components));
    vkStream->read((VkBool32*)&forUnmarshaling->srgb, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_pageable_device_local_memory
void marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pageableDeviceLocalMemory, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pageableDeviceLocalMemory, sizeof(VkBool32));
}

#endif
#ifdef VK_ARM_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderCorePropertiesARM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->pixelRate, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->texelRate, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->fmaRate, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderCorePropertiesARM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->pixelRate, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->texelRate, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->fmaRate, sizeof(uint32_t));
}

#endif
#ifdef VK_EXT_image_sliced_view_of_3d
void marshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->imageSlicedViewOf3D, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->imageSlicedViewOf3D, sizeof(VkBool32));
}

void marshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkImageViewSlicedCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->sliceOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->sliceCount, sizeof(uint32_t));
}

void unmarshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkImageViewSlicedCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->sliceOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->sliceCount, sizeof(uint32_t));
}

#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
void marshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->descriptorSetHostMapping, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->descriptorSetHostMapping, sizeof(VkBool32));
}

void marshal_VkDescriptorSetBindingReferenceVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorSetBindingReferenceVALVE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
        &forMarshaling->descriptorSetLayout, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
}

void unmarshal_VkDescriptorSetBindingReferenceVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorSetBindingReferenceVALVE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
        &cgen_var_0, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
}

void marshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDescriptorSetLayoutHostMappingInfoVALVE* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->descriptorOffset;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((uint32_t*)&forMarshaling->descriptorSize, sizeof(uint32_t));
}

void unmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDescriptorSetLayoutHostMappingInfoVALVE* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    forUnmarshaling->descriptorOffset = (size_t)vkStream->getBe64();
    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSize, sizeof(uint32_t));
}

#endif
#ifdef VK_EXT_depth_clamp_zero_one
void marshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->depthClampZeroOne, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->depthClampZeroOne, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_non_seamless_cube_map
void marshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->nonSeamlessCubeMap, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->nonSeamlessCubeMap, sizeof(VkBool32));
}

#endif
#ifdef VK_QCOM_fragment_density_map_offset
void marshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapOffset, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapOffset, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent2D(vkStream, rootType,
                       (VkExtent2D*)(&forMarshaling->fragmentDensityOffsetGranularity));
}

void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->fragmentDensityOffsetGranularity));
}

void marshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->fragmentDensityOffsetCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->fragmentDensityOffsetCount; ++i) {
            marshal_VkOffset2D(vkStream, rootType,
                               (const VkOffset2D*)(forMarshaling->pFragmentDensityOffsets + i));
        }
    }
}

void unmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->fragmentDensityOffsetCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pFragmentDensityOffsets,
                    forUnmarshaling->fragmentDensityOffsetCount * sizeof(const VkOffset2D));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->fragmentDensityOffsetCount; ++i) {
            unmarshal_VkOffset2D(vkStream, rootType,
                                 (VkOffset2D*)(forUnmarshaling->pFragmentDensityOffsets + i));
        }
    }
}

#endif
#ifdef VK_NV_copy_memory_indirect
void marshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkCopyMemoryIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceAddress*)&forMarshaling->dstAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
                                             VkCopyMemoryIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->dstAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkCopyMemoryToImageIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCopyMemoryToImageIndirectCommandNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
    marshal_VkImageSubresourceLayers(vkStream, rootType,
                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
}

void unmarshal_VkCopyMemoryToImageIndirectCommandNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCopyMemoryToImageIndirectCommandNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
    unmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
}

void marshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->indirectCopy, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->indirectCopy, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkQueueFlags*)&forMarshaling->supportedQueues, sizeof(VkQueueFlags));
}

void unmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkQueueFlags*)&forUnmarshaling->supportedQueues, sizeof(VkQueueFlags));
}

#endif
#ifdef VK_NV_memory_decompression
void marshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkDecompressMemoryRegionNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceAddress*)&forMarshaling->dstAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->compressedSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->decompressedSize, sizeof(VkDeviceSize));
    vkStream->write((VkMemoryDecompressionMethodFlagsNV*)&forMarshaling->decompressionMethod,
                    sizeof(VkMemoryDecompressionMethodFlagsNV));
}

void unmarshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
                                          VkDecompressMemoryRegionNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->dstAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->compressedSize, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->decompressedSize, sizeof(VkDeviceSize));
    vkStream->read((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethod,
                   sizeof(VkMemoryDecompressionMethodFlagsNV));
}

void marshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->memoryDecompression, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMemoryDecompressionFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->memoryDecompression, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkMemoryDecompressionMethodFlagsNV*)&forMarshaling->decompressionMethods,
                    sizeof(VkMemoryDecompressionMethodFlagsNV));
    vkStream->write((uint64_t*)&forMarshaling->maxDecompressionIndirectCount, sizeof(uint64_t));
}

void unmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMemoryDecompressionPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethods,
                   sizeof(VkMemoryDecompressionMethodFlagsNV));
    vkStream->read((uint64_t*)&forUnmarshaling->maxDecompressionIndirectCount, sizeof(uint64_t));
}

#endif
#ifdef VK_NV_linear_color_attachment
void marshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->linearColorAttachment, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->linearColorAttachment, sizeof(VkBool32));
}

#endif
#ifdef VK_GOOGLE_surfaceless_query
#endif
#ifdef VK_EXT_image_compression_control_swapchain
void marshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->imageCompressionControlSwapchain, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->imageCompressionControlSwapchain, sizeof(VkBool32));
}

#endif
#ifdef VK_QCOM_image_processing
void marshal_VkImageViewSampleWeightCreateInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkImageViewSampleWeightCreateInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->filterCenter));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->filterSize));
    vkStream->write((uint32_t*)&forMarshaling->numPhases, sizeof(uint32_t));
}

void unmarshal_VkImageViewSampleWeightCreateInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkImageViewSampleWeightCreateInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->filterCenter));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->filterSize));
    vkStream->read((uint32_t*)&forUnmarshaling->numPhases, sizeof(uint32_t));
}

void marshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageProcessingFeaturesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->textureSampleWeighted, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureBoxFilter, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->textureBlockMatch, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageProcessingFeaturesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->textureSampleWeighted, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureBoxFilter, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->textureBlockMatch, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageProcessingPropertiesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxWeightFilterPhases, sizeof(uint32_t));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxWeightFilterDimension));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxBlockMatchRegion));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxBoxFilterBlockSize));
}

void unmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceImageProcessingPropertiesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxWeightFilterPhases, sizeof(uint32_t));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->maxWeightFilterDimension));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxBlockMatchRegion));
    unmarshal_VkExtent2D(vkStream, rootType,
                         (VkExtent2D*)(&forUnmarshaling->maxBoxFilterBlockSize));
}

#endif
#ifdef VK_EXT_extended_dynamic_state3
void marshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3TessellationDomainOrigin,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClampEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3PolygonMode, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3RasterizationSamples,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3SampleMask, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3AlphaToCoverageEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3AlphaToOneEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LogicOpEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendEquation,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorWriteMask,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3RasterizationStream,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ConservativeRasterizationMode,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->extendedDynamicState3ExtraPrimitiveOverestimationSize,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClipEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3SampleLocationsEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendAdvanced,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ProvokingVertexMode,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LineRasterizationMode,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LineStippleEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClipNegativeOneToOne,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ViewportWScalingEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ViewportSwizzle,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageToColorEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageToColorLocation,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationMode,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationTableEnable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationTable,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageReductionMode,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->extendedDynamicState3RepresentativeFragmentTestEnable,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ShadingRateImageEnable,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3TessellationDomainOrigin,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClampEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3PolygonMode, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationSamples,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleMask, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToCoverageEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToOneEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LogicOpEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEquation,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorWriteMask,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationStream,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ConservativeRasterizationMode,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->extendedDynamicState3ExtraPrimitiveOverestimationSize,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleLocationsEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendAdvanced,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ProvokingVertexMode,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LineRasterizationMode,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LineStippleEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipNegativeOneToOne,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportWScalingEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportSwizzle,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorLocation,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationMode,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTableEnable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTable,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageReductionMode,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->extendedDynamicState3RepresentativeFragmentTestEnable,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ShadingRateImageEnable,
                   sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->dynamicPrimitiveTopologyUnrestricted,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->dynamicPrimitiveTopologyUnrestricted,
                   sizeof(VkBool32));
}

void marshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkColorBlendEquationEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
    vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
}

void unmarshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkColorBlendEquationEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendOp*)&forUnmarshaling->colorBlendOp, sizeof(VkBlendOp));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
    vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
}

void marshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkColorBlendAdvancedEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkBlendOp*)&forMarshaling->advancedBlendOp, sizeof(VkBlendOp));
    vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
    vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
    vkStream->write((VkBool32*)&forMarshaling->clampResults, sizeof(VkBool32));
}

void unmarshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
                                       VkColorBlendAdvancedEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkBlendOp*)&forUnmarshaling->advancedBlendOp, sizeof(VkBlendOp));
    vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
    vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
    vkStream->read((VkBool32*)&forUnmarshaling->clampResults, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_subpass_merge_feedback
void marshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->subpassMergeFeedback, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->subpassMergeFeedback, sizeof(VkBool32));
}

void marshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkRenderPassCreationControlEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->disallowMerging, sizeof(VkBool32));
}

void unmarshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              VkRenderPassCreationControlEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->disallowMerging, sizeof(VkBool32));
}

void marshal_VkRenderPassCreationFeedbackInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassCreationFeedbackInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->postMergeSubpassCount, sizeof(uint32_t));
}

void unmarshal_VkRenderPassCreationFeedbackInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassCreationFeedbackInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->postMergeSubpassCount, sizeof(uint32_t));
}

void marshal_VkRenderPassCreationFeedbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassCreationFeedbackCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkRenderPassCreationFeedbackInfoEXT(
        vkStream, rootType,
        (VkRenderPassCreationFeedbackInfoEXT*)(forMarshaling->pRenderPassFeedback));
}

void unmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassCreationFeedbackCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pRenderPassFeedback,
                    sizeof(VkRenderPassCreationFeedbackInfoEXT));
    unmarshal_VkRenderPassCreationFeedbackInfoEXT(
        vkStream, rootType,
        (VkRenderPassCreationFeedbackInfoEXT*)(forUnmarshaling->pRenderPassFeedback));
}

void marshal_VkRenderPassSubpassFeedbackInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassSubpassFeedbackInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkSubpassMergeStatusEXT*)&forMarshaling->subpassMergeStatus,
                    sizeof(VkSubpassMergeStatusEXT));
    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->write((uint32_t*)&forMarshaling->postMergeIndex, sizeof(uint32_t));
}

void unmarshal_VkRenderPassSubpassFeedbackInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassSubpassFeedbackInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkSubpassMergeStatusEXT*)&forUnmarshaling->subpassMergeStatus,
                   sizeof(VkSubpassMergeStatusEXT));
    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    vkStream->read((uint32_t*)&forUnmarshaling->postMergeIndex, sizeof(uint32_t));
}

void marshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRenderPassSubpassFeedbackCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkRenderPassSubpassFeedbackInfoEXT(
        vkStream, rootType, (VkRenderPassSubpassFeedbackInfoEXT*)(forMarshaling->pSubpassFeedback));
}

void unmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRenderPassSubpassFeedbackCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pSubpassFeedback,
                    sizeof(VkRenderPassSubpassFeedbackInfoEXT));
    unmarshal_VkRenderPassSubpassFeedbackInfoEXT(
        vkStream, rootType,
        (VkRenderPassSubpassFeedbackInfoEXT*)(forUnmarshaling->pSubpassFeedback));
}

#endif
#ifdef VK_LUNARG_direct_driver_loading
void marshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkDirectDriverLoadingInfoLUNARG* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDirectDriverLoadingFlagsLUNARG*)&forMarshaling->flags,
                    sizeof(VkDirectDriverLoadingFlagsLUNARG));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnGetInstanceProcAddr;
    vkStream->putBe64(cgen_var_0);
}

void unmarshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
                                               VkDirectDriverLoadingInfoLUNARG* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDirectDriverLoadingFlagsLUNARG*)&forUnmarshaling->flags,
                   sizeof(VkDirectDriverLoadingFlagsLUNARG));
    forUnmarshaling->pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddrLUNARG)vkStream->getBe64();
}

void marshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkDirectDriverLoadingListLUNARG* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDirectDriverLoadingModeLUNARG*)&forMarshaling->mode,
                    sizeof(VkDirectDriverLoadingModeLUNARG));
    vkStream->write((uint32_t*)&forMarshaling->driverCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->driverCount; ++i) {
            marshal_VkDirectDriverLoadingInfoLUNARG(
                vkStream, rootType,
                (const VkDirectDriverLoadingInfoLUNARG*)(forMarshaling->pDrivers + i));
        }
    }
}

void unmarshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
                                               VkDirectDriverLoadingListLUNARG* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDirectDriverLoadingModeLUNARG*)&forUnmarshaling->mode,
                   sizeof(VkDirectDriverLoadingModeLUNARG));
    vkStream->read((uint32_t*)&forUnmarshaling->driverCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pDrivers,
                    forUnmarshaling->driverCount * sizeof(const VkDirectDriverLoadingInfoLUNARG));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->driverCount; ++i) {
            unmarshal_VkDirectDriverLoadingInfoLUNARG(
                vkStream, rootType,
                (VkDirectDriverLoadingInfoLUNARG*)(forUnmarshaling->pDrivers + i));
        }
    }
}

#endif
#ifdef VK_EXT_shader_module_identifier
void marshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderModuleIdentifier, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderModuleIdentifier, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint8_t*)forMarshaling->shaderModuleIdentifierAlgorithmUUID,
                    VK_UUID_SIZE * sizeof(uint8_t));
}

void unmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint8_t*)forUnmarshaling->shaderModuleIdentifierAlgorithmUUID,
                   VK_UUID_SIZE * sizeof(uint8_t));
}

void marshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->identifierSize, sizeof(uint32_t));
    vkStream->write((const uint8_t*)forMarshaling->pIdentifier,
                    forMarshaling->identifierSize * sizeof(const uint8_t));
}

void unmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->identifierSize, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pIdentifier,
                    forUnmarshaling->identifierSize * sizeof(const uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->pIdentifier,
                   forUnmarshaling->identifierSize * sizeof(const uint8_t));
}

void marshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
                                         const VkShaderModuleIdentifierEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->identifierSize, sizeof(uint32_t));
    vkStream->write((uint8_t*)forMarshaling->identifier,
                    VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
}

void unmarshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
                                           VkShaderModuleIdentifierEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->identifierSize, sizeof(uint32_t));
    vkStream->read((uint8_t*)forUnmarshaling->identifier,
                   VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
}

#endif
#ifdef VK_EXT_rasterization_order_attachment_access
#endif
#ifdef VK_NV_optical_flow
void marshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceOpticalFlowFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->opticalFlow, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceOpticalFlowFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->opticalFlow, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceOpticalFlowPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->supportedOutputGridSizes,
                    sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->supportedHintGridSizes,
                    sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->write((VkBool32*)&forMarshaling->hintSupported, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->costSupported, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->bidirectionalFlowSupported, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->globalFlowSupported, sizeof(VkBool32));
    vkStream->write((uint32_t*)&forMarshaling->minWidth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minHeight, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxWidth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxHeight, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxNumRegionsOfInterest, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceOpticalFlowPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedOutputGridSizes,
                   sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedHintGridSizes,
                   sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->read((VkBool32*)&forUnmarshaling->hintSupported, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->costSupported, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->bidirectionalFlowSupported, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->globalFlowSupported, sizeof(VkBool32));
    vkStream->read((uint32_t*)&forUnmarshaling->minWidth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minHeight, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxWidth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxHeight, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxNumRegionsOfInterest, sizeof(uint32_t));
}

void marshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                            const VkOpticalFlowImageFormatInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkOpticalFlowUsageFlagsNV*)&forMarshaling->usage,
                    sizeof(VkOpticalFlowUsageFlagsNV));
}

void unmarshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                              VkOpticalFlowImageFormatInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkOpticalFlowUsageFlagsNV*)&forUnmarshaling->usage,
                   sizeof(VkOpticalFlowUsageFlagsNV));
}

void marshal_VkOpticalFlowImageFormatPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkOpticalFlowImageFormatPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}

void unmarshal_VkOpticalFlowImageFormatPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkOpticalFlowImageFormatPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}

void marshal_VkOpticalFlowSessionCreateInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkOpticalFlowSessionCreateInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->flowVectorFormat, sizeof(VkFormat));
    vkStream->write((VkFormat*)&forMarshaling->costFormat, sizeof(VkFormat));
    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->outputGridSize,
                    sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->hintGridSize,
                    sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->write((VkOpticalFlowPerformanceLevelNV*)&forMarshaling->performanceLevel,
                    sizeof(VkOpticalFlowPerformanceLevelNV));
    vkStream->write((VkOpticalFlowSessionCreateFlagsNV*)&forMarshaling->flags,
                    sizeof(VkOpticalFlowSessionCreateFlagsNV));
}

void unmarshal_VkOpticalFlowSessionCreateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                                VkOpticalFlowSessionCreateInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->flowVectorFormat, sizeof(VkFormat));
    vkStream->read((VkFormat*)&forUnmarshaling->costFormat, sizeof(VkFormat));
    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->outputGridSize,
                   sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->hintGridSize,
                   sizeof(VkOpticalFlowGridSizeFlagsNV));
    vkStream->read((VkOpticalFlowPerformanceLevelNV*)&forUnmarshaling->performanceLevel,
                   sizeof(VkOpticalFlowPerformanceLevelNV));
    vkStream->read((VkOpticalFlowSessionCreateFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkOpticalFlowSessionCreateFlagsNV));
}

void marshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkOpticalFlowSessionCreatePrivateDataInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->id, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
    vkStream->write((const void*)forMarshaling->pPrivateData, sizeof(const uint8_t));
}

void unmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkOpticalFlowSessionCreatePrivateDataInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->id, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPrivateData, sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pPrivateData, sizeof(const uint8_t));
}

void marshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkOpticalFlowExecuteInfoNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkOpticalFlowExecuteFlagsNV*)&forMarshaling->flags,
                    sizeof(VkOpticalFlowExecuteFlagsNV));
    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
            marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pRegions + i));
        }
    }
}

void unmarshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
                                          VkOpticalFlowExecuteInfoNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkOpticalFlowExecuteFlagsNV*)&forUnmarshaling->flags,
                   sizeof(VkOpticalFlowExecuteFlagsNV));
    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pRegions,
                    forUnmarshaling->regionCount * sizeof(const VkRect2D));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
            unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pRegions + i));
        }
    }
}

#endif
#ifdef VK_EXT_legacy_dithering
void marshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->legacyDithering, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceLegacyDitheringFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->legacyDithering, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_pipeline_protected_access
void marshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineProtectedAccess, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_shader_object
void marshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderObjectFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderObject, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderObjectFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderObject, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderObjectPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint8_t*)forMarshaling->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderBinaryVersion, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderObjectPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint8_t*)forUnmarshaling->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderBinaryVersion, sizeof(uint32_t));
}

void marshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkShaderCreateInfoEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkShaderCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkShaderCreateFlagsEXT));
    vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
    vkStream->write((VkShaderStageFlags*)&forMarshaling->nextStage, sizeof(VkShaderStageFlags));
    vkStream->write((VkShaderCodeTypeEXT*)&forMarshaling->codeType, sizeof(VkShaderCodeTypeEXT));
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
    vkStream->putBe64(cgen_var_0);
    vkStream->write((const void*)forMarshaling->pCode,
                    forMarshaling->codeSize * sizeof(const uint8_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0_0 = (uint64_t)(uintptr_t)forMarshaling->pName;
        vkStream->putBe64(cgen_var_0_0);
        if (forMarshaling->pName) {
            vkStream->putString(forMarshaling->pName);
        }
    } else {
        vkStream->putString(forMarshaling->pName);
    }
    vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSetLayouts;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pSetLayouts) {
        if (forMarshaling->setLayoutCount) {
            uint64_t* cgen_var_1_0;
            vkStream->alloc((void**)&cgen_var_1_0, forMarshaling->setLayoutCount * 8);
            vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
                forMarshaling->pSetLayouts, cgen_var_1_0, forMarshaling->setLayoutCount);
            vkStream->write((uint64_t*)cgen_var_1_0, forMarshaling->setLayoutCount * 8);
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pPushConstantRanges;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pPushConstantRanges) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
                marshal_VkPushConstantRange(
                    vkStream, rootType,
                    (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
    vkStream->putBe64(cgen_var_3);
    if (forMarshaling->pSpecializationInfo) {
        marshal_VkSpecializationInfo(
            vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
    }
}

void unmarshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                     VkShaderCreateInfoEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkShaderCreateFlagsEXT*)&forUnmarshaling->flags,
                   sizeof(VkShaderCreateFlagsEXT));
    vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->nextStage, sizeof(VkShaderStageFlags));
    vkStream->read((VkShaderCodeTypeEXT*)&forUnmarshaling->codeType, sizeof(VkShaderCodeTypeEXT));
    forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
    vkStream->alloc((void**)&forUnmarshaling->pCode,
                    forUnmarshaling->codeSize * sizeof(const uint8_t));
    vkStream->read((void*)forUnmarshaling->pCode,
                   forUnmarshaling->codeSize * sizeof(const uint8_t));
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        forUnmarshaling->pName = (const char*)(uintptr_t)vkStream->getBe64();
        if (forUnmarshaling->pName) {
            vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
        }
    } else {
        vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
    }
    vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pSetLayouts = (const VkDescriptorSetLayout*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSetLayouts) {
        vkStream->alloc((void**)&forUnmarshaling->pSetLayouts,
                        forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
        if (forUnmarshaling->setLayoutCount) {
            uint64_t* cgen_var_1_0;
            vkStream->alloc((void**)&cgen_var_1_0, forUnmarshaling->setLayoutCount * 8);
            vkStream->read((uint64_t*)cgen_var_1_0, forUnmarshaling->setLayoutCount * 8);
            vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
                cgen_var_1_0, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
                forUnmarshaling->setLayoutCount);
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pPushConstantRanges =
        (const VkPushConstantRange*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pPushConstantRanges) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pPushConstantRanges,
            forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i) {
                unmarshal_VkPushConstantRange(
                    vkStream, rootType,
                    (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
            }
        }
    }
    // WARNING PTR CHECK
    forUnmarshaling->pSpecializationInfo =
        (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pSpecializationInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo,
                        sizeof(const VkSpecializationInfo));
        unmarshal_VkSpecializationInfo(
            vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
    }
}

#endif
#ifdef VK_QCOM_tile_properties
void marshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->tileProperties, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceTilePropertiesFeaturesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->tileProperties, sizeof(VkBool32));
}

void marshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
                                  const VkTilePropertiesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->tileSize));
    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->apronSize));
    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->origin));
}

void unmarshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
                                    VkTilePropertiesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->tileSize));
    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->apronSize));
    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->origin));
}

#endif
#ifdef VK_SEC_amigo_profiling
void marshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->amigoProfiling, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAmigoProfilingFeaturesSEC* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->amigoProfiling, sizeof(VkBool32));
}

void marshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkAmigoProfilingSubmitInfoSEC* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->firstDrawTimestamp, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->swapBufferTimestamp, sizeof(uint64_t));
}

void unmarshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
                                             VkAmigoProfilingSubmitInfoSEC* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->firstDrawTimestamp, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->swapBufferTimestamp, sizeof(uint64_t));
}

#endif
#ifdef VK_QCOM_multiview_per_view_viewports
void marshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multiviewPerViewViewports, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewPerViewViewports, sizeof(VkBool32));
}

#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
void marshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRayTracingInvocationReorderModeNV*)&forMarshaling
                        ->rayTracingInvocationReorderReorderingHint,
                    sizeof(VkRayTracingInvocationReorderModeNV));
}

void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRayTracingInvocationReorderModeNV*)&forUnmarshaling
                       ->rayTracingInvocationReorderReorderingHint,
                   sizeof(VkRayTracingInvocationReorderModeNV));
}

void marshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayTracingInvocationReorder, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingInvocationReorder, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_mutable_descriptor_type
#endif
#ifdef VK_ARM_shader_core_builtins
void marshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->shaderCoreBuiltins, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->shaderCoreBuiltins, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->shaderCoreMask, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderCoreCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderWarpsPerCore, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->shaderCoreMask, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderCoreCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderWarpsPerCore, sizeof(uint32_t));
}

#endif
#ifdef VK_EXT_pipeline_library_group_handles
void marshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->pipelineLibraryGroupHandles, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->pipelineLibraryGroupHandles, sizeof(VkBool32));
}

#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
void marshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->multiviewPerViewRenderAreas, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewPerViewRenderAreas, sizeof(VkBool32));
}

void marshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->perViewRenderAreaCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->perViewRenderAreaCount; ++i) {
            marshal_VkRect2D(vkStream, rootType,
                             (const VkRect2D*)(forMarshaling->pPerViewRenderAreas + i));
        }
    }
}

void unmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
    VulkanStream* vkStream, VkStructureType rootType,
    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->perViewRenderAreaCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pPerViewRenderAreas,
                    forUnmarshaling->perViewRenderAreaCount * sizeof(const VkRect2D));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->perViewRenderAreaCount; ++i) {
            unmarshal_VkRect2D(vkStream, rootType,
                               (VkRect2D*)(forUnmarshaling->pPerViewRenderAreas + i));
        }
    }
}

#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
void marshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->attachmentFeedbackLoopDynamicState,
                    sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopDynamicState,
                   sizeof(VkBool32));
}

#endif
#ifdef VK_KHR_acceleration_structure
void marshal_VkAccelerationStructureBuildRangeInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->primitiveCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->primitiveOffset, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->transformOffset, sizeof(uint32_t));
}

void unmarshal_VkAccelerationStructureBuildRangeInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->primitiveCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->primitiveOffset, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->transformOffset, sizeof(uint32_t));
}

void marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkFormat*)&forMarshaling->vertexFormat, sizeof(VkFormat));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
    vkStream->write((VkDeviceSize*)&forMarshaling->vertexStride, sizeof(VkDeviceSize));
    vkStream->write((uint32_t*)&forMarshaling->maxVertex, sizeof(uint32_t));
    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData));
    marshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->transformData));
}

void unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryTrianglesDataKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkFormat*)&forUnmarshaling->vertexFormat, sizeof(VkFormat));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexStride, sizeof(VkDeviceSize));
    vkStream->read((uint32_t*)&forUnmarshaling->maxVertex, sizeof(uint32_t));
    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexData));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->transformData));
}

void marshal_VkAccelerationStructureGeometryAabbsDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
    vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
}

void unmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
}

void marshal_VkAccelerationStructureGeometryInstancesDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->arrayOfPointers, sizeof(VkBool32));
    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
}

void unmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->arrayOfPointers, sizeof(VkBool32));
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
}

void marshal_VkAccelerationStructureGeometryDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryDataKHR* forMarshaling) {
    (void)rootType;
    marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
        vkStream, rootType,
        (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles));
}

void unmarshal_VkAccelerationStructureGeometryDataKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryDataKHR* forUnmarshaling) {
    (void)rootType;
    unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
        vkStream, rootType,
        (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forUnmarshaling->triangles));
}

void marshal_VkAccelerationStructureGeometryKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureGeometryKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkGeometryTypeKHR*)&forMarshaling->geometryType, sizeof(VkGeometryTypeKHR));
    marshal_VkAccelerationStructureGeometryDataKHR(
        vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forMarshaling->geometry));
    vkStream->write((VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
}

void unmarshal_VkAccelerationStructureGeometryKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureGeometryKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkGeometryTypeKHR*)&forUnmarshaling->geometryType, sizeof(VkGeometryTypeKHR));
    unmarshal_VkAccelerationStructureGeometryDataKHR(
        vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forUnmarshaling->geometry));
    vkStream->read((VkGeometryFlagsKHR*)&forUnmarshaling->flags, sizeof(VkGeometryFlagsKHR));
}

void marshal_VkAccelerationStructureBuildGeometryInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type,
                    sizeof(VkAccelerationStructureTypeKHR));
    vkStream->write((VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags,
                    sizeof(VkBuildAccelerationStructureFlagsKHR));
    vkStream->write((VkBuildAccelerationStructureModeKHR*)&forMarshaling->mode,
                    sizeof(VkBuildAccelerationStructureModeKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
        &forMarshaling->srcAccelerationStructure, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
        &forMarshaling->dstAccelerationStructure, &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pGeometries;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pGeometries) {
        if (forMarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
                marshal_VkAccelerationStructureGeometryKHR(
                    vkStream, rootType,
                    (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i));
            }
        }
    }
    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
}

void unmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type,
                   sizeof(VkAccelerationStructureTypeKHR));
    vkStream->read((VkBuildAccelerationStructureFlagsKHR*)&forUnmarshaling->flags,
                   sizeof(VkBuildAccelerationStructureFlagsKHR));
    vkStream->read((VkBuildAccelerationStructureModeKHR*)&forUnmarshaling->mode,
                   sizeof(VkBuildAccelerationStructureModeKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->srcAccelerationStructure, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dstAccelerationStructure, 1);
    vkStream->read((uint32_t*)&forUnmarshaling->geometryCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pGeometries =
        (const VkAccelerationStructureGeometryKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pGeometries) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pGeometries,
            forUnmarshaling->geometryCount * sizeof(const VkAccelerationStructureGeometryKHR));
        if (forUnmarshaling) {
            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i) {
                unmarshal_VkAccelerationStructureGeometryKHR(
                    vkStream, rootType,
                    (VkAccelerationStructureGeometryKHR*)(forUnmarshaling->pGeometries + i));
            }
        }
    }
    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
}

void marshal_VkAccelerationStructureCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags,
                    sizeof(VkAccelerationStructureCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type,
                    sizeof(VkAccelerationStructureTypeKHR));
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void unmarshal_VkAccelerationStructureCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkAccelerationStructureCreateFlagsKHR*)&forUnmarshaling->createFlags,
                   sizeof(VkAccelerationStructureCreateFlagsKHR));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
    vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type,
                   sizeof(VkAccelerationStructureTypeKHR));
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}

void marshal_VkWriteDescriptorSetAccelerationStructureKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pAccelerationStructures) {
        if (forMarshaling->accelerationStructureCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
            vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
                forMarshaling->pAccelerationStructures, cgen_var_0_0,
                forMarshaling->accelerationStructureCount);
            vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
        }
    }
}

void unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->accelerationStructureCount, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pAccelerationStructures =
        (const VkAccelerationStructureKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pAccelerationStructures) {
        vkStream->alloc(
            (void**)&forUnmarshaling->pAccelerationStructures,
            forUnmarshaling->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
        if (forUnmarshaling->accelerationStructureCount) {
            uint64_t* cgen_var_0_0;
            vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
            vkStream->read((uint64_t*)cgen_var_0_0,
                           forUnmarshaling->accelerationStructureCount * 8);
            vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
                cgen_var_0_0, (VkAccelerationStructureKHR*)forUnmarshaling->pAccelerationStructures,
                forUnmarshaling->accelerationStructureCount);
        }
    }
}

void marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->accelerationStructure, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->accelerationStructureCaptureReplay,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->accelerationStructureIndirectBuild,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->accelerationStructureHostCommands, sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->descriptorBindingAccelerationStructureUpdateAfterBind,
        sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructure, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureCaptureReplay,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureIndirectBuild,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureHostCommands,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->descriptorBindingAccelerationStructureUpdateAfterBind,
        sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint64_t*)&forMarshaling->maxGeometryCount, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->maxInstanceCount, sizeof(uint64_t));
    vkStream->write((uint64_t*)&forMarshaling->maxPrimitiveCount, sizeof(uint64_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorAccelerationStructures,
                    sizeof(uint32_t));
    vkStream->write(
        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
        sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
                    sizeof(uint32_t));
    vkStream->write(
        (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures,
        sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->minAccelerationStructureScratchOffsetAlignment,
                    sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint64_t*)&forUnmarshaling->maxGeometryCount, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxInstanceCount, sizeof(uint64_t));
    vkStream->read((uint64_t*)&forUnmarshaling->maxPrimitiveCount, sizeof(uint64_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorAccelerationStructures,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures,
                   sizeof(uint32_t));
    vkStream->read(
        (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures,
        sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->minAccelerationStructureScratchOffsetAlignment,
                   sizeof(uint32_t));
}

void marshal_VkAccelerationStructureDeviceAddressInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
        &forMarshaling->accelerationStructure, &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}

void unmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure, 1);
}

void marshal_VkAccelerationStructureVersionInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureVersionInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((const uint8_t*)forMarshaling->pVersionData,
                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
}

void unmarshal_VkAccelerationStructureVersionInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureVersionInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->alloc((void**)&forUnmarshaling->pVersionData,
                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
    vkStream->read((uint8_t*)forUnmarshaling->pVersionData,
                   2 * VK_UUID_SIZE * sizeof(const uint8_t));
}

void marshal_VkCopyAccelerationStructureToMemoryInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src,
                                                                         &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
    vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
                    sizeof(VkCopyAccelerationStructureModeKHR));
}

void unmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
    vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
                   sizeof(VkCopyAccelerationStructureModeKHR));
}

void marshal_VkCopyMemoryToAccelerationStructureInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst,
                                                                         &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
                    sizeof(VkCopyAccelerationStructureModeKHR));
}

void unmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    unmarshal_VkDeviceOrHostAddressConstKHR(
        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
    vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
                   sizeof(VkCopyAccelerationStructureModeKHR));
}

void marshal_VkCopyAccelerationStructureInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkCopyAccelerationStructureInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    uint64_t cgen_var_0;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src,
                                                                         &cgen_var_0, 1);
    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
    uint64_t cgen_var_1;
    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst,
                                                                         &cgen_var_1, 1);
    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
                    sizeof(VkCopyAccelerationStructureModeKHR));
}

void unmarshal_VkCopyAccelerationStructureInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkCopyAccelerationStructureInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    uint64_t cgen_var_0;
    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
    uint64_t cgen_var_1;
    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
        &cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
    vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
                   sizeof(VkCopyAccelerationStructureModeKHR));
}

void marshal_VkAccelerationStructureBuildSizesInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkDeviceSize*)&forMarshaling->accelerationStructureSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->updateScratchSize, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->buildScratchSize, sizeof(VkDeviceSize));
}

void unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkDeviceSize*)&forUnmarshaling->accelerationStructureSize,
                   sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->updateScratchSize, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->buildScratchSize, sizeof(VkDeviceSize));
}

#endif
#ifdef VK_KHR_ray_tracing_pipeline
void marshal_VkRayTracingShaderGroupCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
                    sizeof(VkRayTracingShaderGroupTypeKHR));
    vkStream->write((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->anyHitShader, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->intersectionShader, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pShaderGroupCaptureReplayHandle;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pShaderGroupCaptureReplayHandle) {
        vkStream->write((const void*)forMarshaling->pShaderGroupCaptureReplayHandle,
                        sizeof(const uint8_t));
    }
}

void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type,
                   sizeof(VkRayTracingShaderGroupTypeKHR));
    vkStream->read((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->anyHitShader, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->intersectionShader, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pShaderGroupCaptureReplayHandle = (const void*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pShaderGroupCaptureReplayHandle) {
        vkStream->alloc((void**)&forUnmarshaling->pShaderGroupCaptureReplayHandle,
                        sizeof(const uint8_t));
        vkStream->read((void*)forUnmarshaling->pShaderGroupCaptureReplayHandle,
                       sizeof(const uint8_t));
    }
}

void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
}

void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
}

void marshal_VkRayTracingPipelineCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkRayTracingPipelineCreateInfoKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
            marshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
    if (forMarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
            marshal_VkRayTracingShaderGroupCreateInfoKHR(
                vkStream, rootType,
                (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
        }
    }
    vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInfo;
    vkStream->putBe64(cgen_var_0);
    if (forMarshaling->pLibraryInfo) {
        marshal_VkPipelineLibraryCreateInfoKHR(
            vkStream, rootType,
            (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInterface;
    vkStream->putBe64(cgen_var_1);
    if (forMarshaling->pLibraryInterface) {
        marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
            vkStream, rootType,
            (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface));
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
    vkStream->putBe64(cgen_var_2);
    if (forMarshaling->pDynamicState) {
        marshal_VkPipelineDynamicStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
    }
    uint64_t cgen_var_3;
    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_3,
                                                               1);
    vkStream->write((uint64_t*)&cgen_var_3, 1 * 8);
    uint64_t cgen_var_4;
    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
                                                         &cgen_var_4, 1);
    vkStream->write((uint64_t*)&cgen_var_4, 1 * 8);
    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}

void unmarshal_VkRayTracingPipelineCreateInfoKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkRayTracingPipelineCreateInfoKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
    vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
    vkStream->alloc((void**)&forUnmarshaling->pStages,
                    forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
            unmarshal_VkPipelineShaderStageCreateInfo(
                vkStream, rootType,
                (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
    vkStream->alloc(
        (void**)&forUnmarshaling->pGroups,
        forUnmarshaling->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
    if (forUnmarshaling) {
        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
            unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
                vkStream, rootType,
                (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
        }
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
    // WARNING PTR CHECK
    forUnmarshaling->pLibraryInfo =
        (const VkPipelineLibraryCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pLibraryInfo) {
        vkStream->alloc((void**)&forUnmarshaling->pLibraryInfo,
                        sizeof(const VkPipelineLibraryCreateInfoKHR));
        unmarshal_VkPipelineLibraryCreateInfoKHR(
            vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pLibraryInterface =
        (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pLibraryInterface) {
        vkStream->alloc((void**)&forUnmarshaling->pLibraryInterface,
                        sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
        unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
            vkStream, rootType,
            (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
    }
    // WARNING PTR CHECK
    forUnmarshaling->pDynamicState =
        (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
    if (forUnmarshaling->pDynamicState) {
        vkStream->alloc((void**)&forUnmarshaling->pDynamicState,
                        sizeof(const VkPipelineDynamicStateCreateInfo));
        unmarshal_VkPipelineDynamicStateCreateInfo(
            vkStream, rootType,
            (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
    }
    uint64_t cgen_var_3;
    vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
        &cgen_var_3, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
    uint64_t cgen_var_4;
    vkStream->read((uint64_t*)&cgen_var_4, 1 * 8);
    vkStream->handleMapping()->mapHandles_u64_VkPipeline(
        &cgen_var_4, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}

void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayTracingPipeline, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
                    sizeof(VkBool32));
    vkStream->write(
        (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
        sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipeline, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
                   sizeof(VkBool32));
    vkStream->read(
        (VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
        sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxRayRecursionDepth, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleCaptureReplaySize,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
}

void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxRayRecursionDepth, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleCaptureReplaySize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
}

void marshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkStridedDeviceAddressRegionKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
    vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}

void unmarshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkStridedDeviceAddressRegionKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}

void marshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           const VkTraceRaysIndirectCommandKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
}

void unmarshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkTraceRaysIndirectCommandKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
}

#endif
#ifdef VK_KHR_ray_query
void marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->rayQuery, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->rayQuery, sizeof(VkBool32));
}

#endif
#ifdef VK_EXT_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMeshShaderFeaturesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((VkBool32*)&forMarshaling->taskShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->meshShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->multiviewMeshShader, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRateMeshShader,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->meshShaderQueries, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMeshShaderFeaturesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((VkBool32*)&forUnmarshaling->taskShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->meshShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->multiviewMeshShader, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateMeshShader,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->meshShaderQueries, sizeof(VkBool32));
}

void marshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMeshShaderPropertiesEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
    vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupTotalCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskPayloadSize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskSharedMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxTaskPayloadAndSharedMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshWorkGroupTotalCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
    vkStream->write((uint32_t*)forMarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshSharedMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshPayloadAndSharedMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshPayloadAndOutputMemorySize, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputComponents, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputVertices, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputLayers, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerPrimitiveGranularity, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPreferredTaskWorkGroupInvocations,
                    sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->maxPreferredMeshWorkGroupInvocations,
                    sizeof(uint32_t));
    vkStream->write((VkBool32*)&forMarshaling->prefersLocalInvocationVertexOutput,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->prefersLocalInvocationPrimitiveOutput,
                    sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->prefersCompactVertexOutput, sizeof(VkBool32));
    vkStream->write((VkBool32*)&forMarshaling->prefersCompactPrimitiveOutput, sizeof(VkBool32));
}

void unmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkPhysicalDeviceMeshShaderPropertiesEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forUnmarshaling->sType;
    }
    size_t pNext_size;
    pNext_size = vkStream->getBe32();
    forUnmarshaling->pNext = nullptr;
    if (pNext_size) {
        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
        vkStream->alloc((void**)&forUnmarshaling->pNext,
                        goldfish_vk_extension_struct_size_with_stream_features(
                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
        *(VkStructureType*)forUnmarshaling->pNext = extType;
        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
    }
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupTotalCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskPayloadSize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskSharedMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskPayloadAndSharedMemorySize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshWorkGroupTotalCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
    vkStream->read((uint32_t*)forUnmarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshSharedMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshPayloadAndSharedMemorySize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputMemorySize, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshPayloadAndOutputMemorySize,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputComponents, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputVertices, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputLayers, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPreferredTaskWorkGroupInvocations,
                   sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->maxPreferredMeshWorkGroupInvocations,
                   sizeof(uint32_t));
    vkStream->read((VkBool32*)&forUnmarshaling->prefersLocalInvocationVertexOutput,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->prefersLocalInvocationPrimitiveOutput,
                   sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->prefersCompactVertexOutput, sizeof(VkBool32));
    vkStream->read((VkBool32*)&forUnmarshaling->prefersCompactPrimitiveOutput, sizeof(VkBool32));
}

void marshal_VkDrawMeshTasksIndirectCommandEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    const VkDrawMeshTasksIndirectCommandEXT* forMarshaling) {
    (void)rootType;
    vkStream->write((uint32_t*)&forMarshaling->groupCountX, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->groupCountY, sizeof(uint32_t));
    vkStream->write((uint32_t*)&forMarshaling->groupCountZ, sizeof(uint32_t));
}

void unmarshal_VkDrawMeshTasksIndirectCommandEXT(
    VulkanStream* vkStream, VkStructureType rootType,
    VkDrawMeshTasksIndirectCommandEXT* forUnmarshaling) {
    (void)rootType;
    vkStream->read((uint32_t*)&forUnmarshaling->groupCountX, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->groupCountY, sizeof(uint32_t));
    vkStream->read((uint32_t*)&forUnmarshaling->groupCountZ, sizeof(uint32_t));
}

#endif
void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                              const void* structExtension) {
    VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
    size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
        vkStream->getFeatureBits(), rootType, structExtension);
    if (!currExtSize && structExtension) {
        // unknown struct extension; skip and call on its pNext field
        marshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
        return;
    } else {
        // known or null extension struct
        vkStream->putBe32(currExtSize);
        if (!currExtSize) {
            // exit if this was a null extension struct (size == 0 in this branch)
            return;
        }
    }
    vkStream->write(structExtension, sizeof(VkStructureType));
    if (!structExtension) {
        return;
    }
    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
    switch (structType) {
#ifdef VK_VERSION_1_0
        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
            marshal_VkShaderModuleCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension));
            break;
        }
#endif
#ifdef VK_VERSION_1_1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
            marshal_VkPhysicalDeviceSubgroupProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
            marshal_VkPhysicalDevice16BitStorageFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
            marshal_VkMemoryDedicatedRequirements(
                vkStream, rootType,
                reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
            marshal_VkMemoryDedicatedAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
            marshal_VkMemoryAllocateFlagsInfo(
                vkStream, rootType,
                reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
            marshal_VkDeviceGroupRenderPassBeginInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
            marshal_VkDeviceGroupCommandBufferBeginInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
            marshal_VkDeviceGroupSubmitInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
            marshal_VkDeviceGroupBindSparseInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
            marshal_VkBindBufferMemoryDeviceGroupInfo(
                vkStream, rootType,
                reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
            marshal_VkBindImageMemoryDeviceGroupInfo(
                vkStream, rootType,
                reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
            marshal_VkDeviceGroupDeviceCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
            marshal_VkPhysicalDeviceFeatures2(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
            marshal_VkPhysicalDevicePointClippingProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
            marshal_VkRenderPassInputAttachmentAspectCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
            marshal_VkImageViewUsageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
            marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
            marshal_VkRenderPassMultiviewCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
            marshal_VkPhysicalDeviceMultiviewFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
            marshal_VkPhysicalDeviceMultiviewProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
            marshal_VkPhysicalDeviceVariablePointersFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
            marshal_VkPhysicalDeviceProtectedMemoryFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
            marshal_VkPhysicalDeviceProtectedMemoryProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
            marshal_VkProtectedSubmitInfo(
                vkStream, rootType,
                reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
            marshal_VkSamplerYcbcrConversionInfo(
                vkStream, rootType,
                reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
            marshal_VkBindImagePlaneMemoryInfo(
                vkStream, rootType,
                reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
            marshal_VkImagePlaneMemoryRequirementsInfo(
                vkStream, rootType,
                reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
            marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
            marshal_VkSamplerYcbcrConversionImageFormatProperties(
                vkStream, rootType,
                reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
            marshal_VkPhysicalDeviceExternalImageFormatInfo(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
            marshal_VkExternalImageFormatProperties(
                vkStream, rootType,
                reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
            marshal_VkPhysicalDeviceIDProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
            marshal_VkExternalMemoryImageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
            marshal_VkExternalMemoryBufferCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
            marshal_VkExportMemoryAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
            marshal_VkExportFenceCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
            marshal_VkExportSemaphoreCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
            marshal_VkPhysicalDeviceMaintenance3Properties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
            marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_VERSION_1_2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
            marshal_VkPhysicalDeviceVulkan11Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
            marshal_VkPhysicalDeviceVulkan11Properties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
            marshal_VkPhysicalDeviceVulkan12Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
            marshal_VkPhysicalDeviceVulkan12Properties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
            marshal_VkImageFormatListCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
            marshal_VkPhysicalDevice8BitStorageFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
            marshal_VkPhysicalDeviceDriverProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
            marshal_VkPhysicalDeviceShaderAtomicInt64Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
            marshal_VkPhysicalDeviceShaderFloat16Int8Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
            marshal_VkPhysicalDeviceFloatControlsProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
            marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
            marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
            marshal_VkPhysicalDeviceDescriptorIndexingProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
            marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
            marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
                vkStream, rootType,
                reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
            marshal_VkSubpassDescriptionDepthStencilResolve(
                vkStream, rootType,
                reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
            marshal_VkPhysicalDeviceDepthStencilResolveProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
            marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
            marshal_VkImageStencilUsageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
            marshal_VkSamplerReductionModeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
            marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
            marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
            marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
            marshal_VkFramebufferAttachmentsCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
            marshal_VkRenderPassAttachmentBeginInfo(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
            marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
            marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
            marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
            marshal_VkAttachmentReferenceStencilLayout(
                vkStream, rootType,
                reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
            marshal_VkAttachmentDescriptionStencilLayout(
                vkStream, rootType,
                reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
            marshal_VkPhysicalDeviceHostQueryResetFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
            marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
            marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
            marshal_VkSemaphoreTypeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
            marshal_VkTimelineSemaphoreSubmitInfo(
                vkStream, rootType,
                reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
            marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
            marshal_VkBufferOpaqueCaptureAddressCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
            marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension));
            break;
        }
#endif
#ifdef VK_VERSION_1_3
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
            marshal_VkPhysicalDeviceVulkan13Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
            marshal_VkPhysicalDeviceVulkan13Properties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
            marshal_VkPipelineCreationFeedbackCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
            marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
            marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
            marshal_VkPhysicalDevicePrivateDataFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
            marshal_VkDevicePrivateDataCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
            marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
            marshal_VkMemoryBarrier2(vkStream, rootType,
                                     reinterpret_cast<const VkMemoryBarrier2*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
            marshal_VkPhysicalDeviceSynchronization2Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
            marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
            marshal_VkPhysicalDeviceImageRobustnessFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
            marshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
            marshal_VkPhysicalDeviceSubgroupSizeControlProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
            marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
            marshal_VkPhysicalDeviceInlineUniformBlockFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
            marshal_VkPhysicalDeviceInlineUniformBlockProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
            marshal_VkWriteDescriptorSetInlineUniformBlock(
                vkStream, rootType,
                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
            marshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
            marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
            marshal_VkPipelineRenderingCreateInfo(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
            marshal_VkPhysicalDeviceDynamicRenderingFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
            marshal_VkCommandBufferInheritanceRenderingInfo(
                vkStream, rootType,
                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
            marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
            marshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
            marshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
            marshal_VkFormatProperties3(
                vkStream, rootType, reinterpret_cast<const VkFormatProperties3*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
            marshal_VkPhysicalDeviceMaintenance4Features(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
            marshal_VkPhysicalDeviceMaintenance4Properties(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_swapchain
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
            marshal_VkImageSwapchainCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
            marshal_VkBindImageMemorySwapchainInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
            marshal_VkDeviceGroupPresentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
            marshal_VkDeviceGroupSwapchainCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_display_swapchain
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
            marshal_VkDisplayPresentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_video_queue
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
            marshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
            marshal_VkQueueFamilyVideoPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
            marshal_VkVideoProfileInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoProfileInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
            marshal_VkVideoProfileListInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoProfileListInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_queue
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
            marshal_VkVideoDecodeCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
            marshal_VkVideoDecodeUsageInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_h264
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
            marshal_VkVideoDecodeH264ProfileInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
            marshal_VkVideoDecodeH264CapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
            marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
            marshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
            marshal_VkVideoDecodeH264PictureInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
            marshal_VkVideoDecodeH264DpbSlotInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_dynamic_rendering
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
            marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
            marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
            marshal_VkAttachmentSampleCountInfoAMD(
                vkStream, rootType,
                reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
            marshal_VkMultiviewPerViewAttributesInfoNVX(
                vkStream, rootType,
                reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
            marshal_VkImportMemoryWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
            marshal_VkExportMemoryWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_fd
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
            marshal_VkImportMemoryFdInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
            marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_external_semaphore_win32
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
            marshal_VkExportSemaphoreWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
            marshal_VkD3D12FenceSubmitInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_push_descriptor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
            marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_incremental_present
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
            marshal_VkPresentRegionsKHR(
                vkStream, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_shared_presentable_image
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
            marshal_VkSharedPresentSurfaceCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_external_fence_win32
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
            marshal_VkExportFenceWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_performance_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
            marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
            marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
            marshal_VkQueryPoolPerformanceCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
            marshal_VkPerformanceQuerySubmitInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_portability_subset
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
            marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
            marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_KHR_shader_clock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
            marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_h265
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
            marshal_VkVideoDecodeH265ProfileInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
            marshal_VkVideoDecodeH265CapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
            marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
            marshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
            marshal_VkVideoDecodeH265PictureInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
            marshal_VkVideoDecodeH265DpbSlotInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_global_priority
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
            marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
            marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
            marshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_fragment_shading_rate
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
            marshal_VkFragmentShadingRateAttachmentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
            marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
            marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
            marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_surface_protected_capabilities
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
            marshal_VkSurfaceProtectedCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_present_wait
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
            marshal_VkPhysicalDevicePresentWaitFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
            marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_pipeline_library
        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
            marshal_VkPipelineLibraryCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_present_id
        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
            marshal_VkPresentIdKHR(vkStream, rootType,
                                   reinterpret_cast<const VkPresentIdKHR*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
            marshal_VkPhysicalDevicePresentIdFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_video_encode_queue
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
            marshal_VkVideoEncodeCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
            marshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
            marshal_VkVideoEncodeUsageInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
            marshal_VkVideoEncodeRateControlLayerInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
            marshal_VkVideoEncodeRateControlInfoKHR(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_KHR_synchronization2
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
            marshal_VkQueueFamilyCheckpointProperties2NV(
                vkStream, rootType,
                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
            break;
        }
#endif
#ifdef VK_KHR_fragment_shader_barycentric
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
            marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
            marshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
            marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<
                    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
            marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_maintenance1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
            marshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_position_fetch
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
            marshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_ANDROID_native_buffer
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
            marshal_VkNativeBufferANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkNativeBufferANDROID*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_debug_report
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
            marshal_VkDebugReportCallbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_rasterization_order
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
            marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
            marshal_VkDedicatedAllocationImageCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
            marshal_VkDedicatedAllocationBufferCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
            marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_transform_feedback
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
            marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
            marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_video_encode_h264
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
            marshal_VkVideoEncodeH264CapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
            marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
            marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
            marshal_VkVideoEncodeH264VclFrameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
            marshal_VkVideoEncodeH264ProfileInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264ProfileInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
            marshal_VkVideoEncodeH264RateControlInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
            marshal_VkVideoEncodeH264RateControlLayerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_EXT_video_encode_h265
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
            marshal_VkVideoEncodeH265CapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
            marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
            marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
            marshal_VkVideoEncodeH265VclFrameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
            marshal_VkVideoEncodeH265DpbSlotInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
            marshal_VkVideoEncodeH265ProfileInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
            marshal_VkVideoEncodeH265RateControlInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
            marshal_VkVideoEncodeH265RateControlLayerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_AMD_texture_gather_bias_lod
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
            marshal_VkTextureLODGatherFormatPropertiesAMD(
                vkStream, rootType,
                reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_corner_sampled_image
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
            marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_external_memory
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
            marshal_VkExternalMemoryImageCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
            marshal_VkExportMemoryAllocateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
            marshal_VkImportMemoryWin32HandleInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
            marshal_VkExportMemoryWin32HandleInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
            marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_validation_flags
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
            marshal_VkValidationFlagsEXT(
                vkStream, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_astc_decode_mode
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
            marshal_VkImageViewASTCDecodeModeEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_robustness
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
            marshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
            marshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
            marshal_VkPipelineRobustnessCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_conditional_rendering
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
            marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
            marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_clip_space_w_scaling
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineViewportWScalingStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_display_control
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
            marshal_VkSwapchainCounterCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_GOOGLE_display_timing
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
            marshal_VkPresentTimesInfoGOOGLE(
                vkStream, rootType,
                reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension));
            break;
        }
#endif
#ifdef VK_NVX_multiview_per_view_attributes
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
            marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_viewport_swizzle
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_conservative_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_depth_clip_enable
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_debug_utils
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
            marshal_VkDebugUtilsObjectNameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
            marshal_VkDebugUtilsMessengerCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
            marshal_VkAndroidHardwareBufferUsageANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
            marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
            marshal_VkImportAndroidHardwareBufferInfoANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
            marshal_VkExternalFormatANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
            marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
                vkStream, rootType,
                reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_sample_locations
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
            marshal_VkSampleLocationsInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
            marshal_VkRenderPassSampleLocationsBeginInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_blend_operation_advanced
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
            marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_fragment_coverage_to_color
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineCoverageToColorStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_framebuffer_mixed_samples
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineCoverageModulationStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_shader_sm_builtins
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
            marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_drm_format_modifier
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
            marshal_VkDrmFormatModifierPropertiesListEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
            marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
            marshal_VkImageDrmFormatModifierListCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
            marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
            marshal_VkDrmFormatModifierPropertiesList2EXT(
                vkStream, rootType,
                reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_validation_cache
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
            marshal_VkShaderModuleValidationCacheCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_shading_rate_image
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
            marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
            marshal_VkWriteDescriptorSetAccelerationStructureNV(
                vkStream, rootType,
                reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceRayTracingPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_representative_fragment_test
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
            marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_filter_cubic
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
            marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
            marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_external_memory_host
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
            marshal_VkImportMemoryHostPointerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_AMD_pipeline_compiler_control
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
            marshal_VkPipelineCompilerControlCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
            marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_memory_overallocation_behavior
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
            marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_vertex_attribute_divisor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
            marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_GGP_frame_token
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
            marshal_VkPresentFrameTokenGGP(
                vkStream, rootType,
                reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_compute_shader_derivatives
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
            marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_mesh_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
            marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_shader_image_footprint
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
            marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_scissor_exclusive
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
            marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
            marshal_VkQueueFamilyCheckpointPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_INTEL_shader_integer_functions2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
            marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_INTEL_performance_query
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
            marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
                vkStream, rootType,
                reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pci_bus_info
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
            marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_display_native_hdr
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
            marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
                vkStream, rootType,
                reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
            marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_fragment_density_map
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
                    marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension));
                    break;
                }
                case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
                    marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    marshal_VkImportColorBufferGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
                    break;
                }
                default: {
                    marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension));
                    break;
                }
            }
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
                    marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
                            structExtension));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    marshal_VkCreateBlobGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<const VkCreateBlobGOOGLE*>(structExtension));
                    break;
                }
                default: {
                    marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
                            structExtension));
                    break;
                }
            }
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
                    marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension));
                    break;
                }
                case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
                    marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    marshal_VkImportBufferGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
                    break;
                }
                default: {
                    marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension));
                    break;
                }
            }
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
            marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_device_coherent_memory
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
            marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_image_atomic_int64
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_memory_budget
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_memory_priority
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
            marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
            marshal_VkMemoryPriorityAllocateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
            marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_buffer_device_address
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
            marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
            marshal_VkBufferDeviceAddressCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_validation_features
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
            marshal_VkValidationFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_cooperative_matrix
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
            marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_coverage_reduction_mode
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
            marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineCoverageReductionStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_fragment_shader_interlock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
            marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_ycbcr_image_arrays
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
            marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_provoking_vertex
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
            marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
            marshal_VkSurfaceFullScreenExclusiveInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
            marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
            marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_line_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
            marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
            marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_atomic_float
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_index_type_uint8
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
            marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_atomic_float2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_surface_maintenance1
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
            marshal_VkSurfacePresentModeEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfacePresentModeEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
            marshal_VkSurfacePresentScalingCapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
            marshal_VkSurfacePresentModeCompatibilityEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_swapchain_maintenance1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
            marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
            marshal_VkSwapchainPresentFenceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
            marshal_VkSwapchainPresentModesCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
            marshal_VkSwapchainPresentModeInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
            marshal_VkSwapchainPresentScalingCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_device_generated_commands
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
            marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
            marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_inherited_viewport_scissor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
            marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
            marshal_VkCommandBufferInheritanceViewportScissorInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_texel_buffer_alignment
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_render_pass_transform
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
            marshal_VkRenderPassTransformBeginInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
            marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_device_memory_report
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
            marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_robustness2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
            marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_custom_border_color
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
            marshal_VkSamplerCustomBorderColorCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
            marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_present_barrier
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
            marshal_VkPhysicalDevicePresentBarrierFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
            marshal_VkSurfaceCapabilitiesPresentBarrierNV(
                vkStream, rootType,
                reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
            marshal_VkSwapchainPresentBarrierCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostics_config
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
            marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
            marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_NV_low_latency
        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
            marshal_VkQueryLowLatencySupportNV(
                vkStream, rootType,
                reinterpret_cast<const VkQueryLowLatencySupportNV*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_metal_objects
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
            marshal_VkExportMetalObjectCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
            marshal_VkExportMetalDeviceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
            marshal_VkExportMetalCommandQueueInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
            marshal_VkExportMetalBufferInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalBufferInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
            marshal_VkImportMetalBufferInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImportMetalBufferInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
            marshal_VkExportMetalTextureInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalTextureInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
            marshal_VkImportMetalTextureInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImportMetalTextureInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
            marshal_VkExportMetalIOSurfaceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
            marshal_VkImportMetalIOSurfaceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
            marshal_VkExportMetalSharedEventInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
            marshal_VkImportMetalSharedEventInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
            marshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
            marshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
            marshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_graphics_pipeline_library
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
            marshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
            marshal_VkGraphicsPipelineLibraryCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
            marshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_fragment_shading_rate_enums
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
            marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
            marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing_motion_blur
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
            marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
                vkStream, rootType,
                reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
            marshal_VkAccelerationStructureMotionInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
            marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
            marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_fragment_density_map2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
            marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_rotated_copy_commands
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
            marshal_VkCopyCommandTransformInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_compression_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
            marshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
            marshal_VkImageCompressionControlEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
            marshal_VkImageCompressionPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_4444_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
            marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_device_fault
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceFaultFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_ARM_rasterization_order_attachment_access
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
            marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<
                    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_rgba10x6_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
            marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_VALVE_mutable_descriptor_type
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
            marshal_VkMutableDescriptorTypeCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_physical_device_drm
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceDrmPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_device_address_binding_report
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
            marshal_VkDeviceAddressBindingCallbackDataEXT(
                vkStream, rootType,
                reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_depth_clip_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
            marshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
            marshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_primitive_topology_list_restart
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
            marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_FUCHSIA_external_memory
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
            marshal_VkImportMemoryZirconHandleInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension));
            break;
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
            marshal_VkImportMemoryBufferCollectionFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
            marshal_VkBufferCollectionImageCreateInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
            marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_HUAWEI_subpass_shading
        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
            marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
            marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
            marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_HUAWEI_invocation_mask
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
            marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_external_memory_rdma
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
            marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
            marshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
            marshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<
                    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
            marshal_VkSubpassResolvePerformanceQueryEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
            marshal_VkMultisampledRenderToSingleSampledInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
            marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_color_write_enable
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
            marshal_VkPipelineColorWriteCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_primitives_generated_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
            marshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
            marshal_VkImportColorBufferGOOGLE(
                vkStream, rootType,
                reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
            marshal_VkImportBufferGOOGLE(
                vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE: {
            marshal_VkCreateBlobGOOGLE(
                vkStream, rootType, reinterpret_cast<const VkCreateBlobGOOGLE*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_view_min_lod
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
            marshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
            marshal_VkImageViewMinLodCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_multi_draw
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
            marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_2d_view_of_3d
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
            marshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_tile_image
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
            marshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
            marshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
                vkStream, rootType,
                reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_displacement_micromap
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
            marshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
            marshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
                vkStream, rootType,
                reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
                    structExtension));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
            marshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
            marshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_border_color_swizzle
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
            marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pageable_device_local_memory
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
            marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_ARM_shader_core_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
            marshal_VkPhysicalDeviceShaderCorePropertiesARM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_sliced_view_of_3d
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
            marshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
            marshal_VkImageViewSlicedCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
            marshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_depth_clamp_zero_one
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_non_seamless_cube_map
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
            marshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_fragment_density_map_offset
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
            marshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
            marshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
            marshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_copy_memory_indirect
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
            marshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_memory_decompression
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
            marshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_linear_color_attachment
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
            marshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_image_compression_control_swapchain
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
            marshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<
                    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_image_processing
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
            marshal_VkImageViewSampleWeightCreateInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
            marshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
            marshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
            marshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_subpass_merge_feedback
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
            marshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
            marshal_VkRenderPassCreationControlEXT(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassCreationControlEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
            marshal_VkRenderPassCreationFeedbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
            marshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension));
            break;
        }
#endif
#ifdef VK_LUNARG_direct_driver_loading
        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
            marshal_VkDirectDriverLoadingListLUNARG(
                vkStream, rootType,
                reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_module_identifier
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
            marshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_optical_flow
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
            marshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
            marshal_VkOpticalFlowImageFormatInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
            marshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
                vkStream, rootType,
                reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_legacy_dithering
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
            marshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_protected_access
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
            marshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_shader_object
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
            marshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_tile_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
            marshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_SEC_amigo_profiling
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
            marshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
            marshal_VkAmigoProfilingSubmitInfoSEC(
                vkStream, rootType,
                reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_multiview_per_view_viewports
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
            marshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
            marshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
            marshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_ARM_shader_core_builtins
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
            marshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
            marshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_library_group_handles
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
            marshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
            marshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
            marshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
            marshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<
                    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
            marshal_VkWriteDescriptorSetAccelerationStructureKHR(
                vkStream, rootType,
                reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
            marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
            marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
            marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                    structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
            marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
                    structExtension));
            break;
        }
#endif
#ifdef VK_KHR_ray_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
            marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension));
            break;
        }
#endif
#ifdef VK_EXT_mesh_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
            marshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
            marshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension));
            break;
        }
#endif
        default: {
            // fatal; the switch is only taken if the extension struct is known
            abort();
        }
    }
}

void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                                void* structExtension_out) {
    VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
    size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
        vkStream->getFeatureBits(), rootType, structExtension_out);
    if (!currExtSize && structExtension_out) {
        // unknown struct extension; skip and call on its pNext field
        unmarshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
        return;
    } else {
        // known or null extension struct
        if (!currExtSize) {
            // exit if this was a null extension struct (size == 0 in this branch)
            return;
        }
    }
    if (!structExtension_out) {
        return;
    }
    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
    switch (structType) {
#ifdef VK_VERSION_1_0
        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
            unmarshal_VkShaderModuleCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_VERSION_1_1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
            unmarshal_VkPhysicalDeviceSubgroupProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
            unmarshal_VkPhysicalDevice16BitStorageFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
            unmarshal_VkMemoryDedicatedRequirements(
                vkStream, rootType,
                reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
            unmarshal_VkMemoryDedicatedAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
            unmarshal_VkMemoryAllocateFlagsInfo(
                vkStream, rootType,
                reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
            unmarshal_VkDeviceGroupRenderPassBeginInfo(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
            unmarshal_VkDeviceGroupCommandBufferBeginInfo(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
            unmarshal_VkDeviceGroupSubmitInfo(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
            unmarshal_VkDeviceGroupBindSparseInfo(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
            unmarshal_VkBindBufferMemoryDeviceGroupInfo(
                vkStream, rootType,
                reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
            unmarshal_VkBindImageMemoryDeviceGroupInfo(
                vkStream, rootType,
                reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
            unmarshal_VkDeviceGroupDeviceCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
            unmarshal_VkPhysicalDeviceFeatures2(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
            unmarshal_VkPhysicalDevicePointClippingProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
            unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
            unmarshal_VkImageViewUsageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
            unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
            unmarshal_VkRenderPassMultiviewCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
            unmarshal_VkPhysicalDeviceMultiviewFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
            unmarshal_VkPhysicalDeviceMultiviewProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
            unmarshal_VkPhysicalDeviceVariablePointersFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
            unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
            unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
            unmarshal_VkProtectedSubmitInfo(
                vkStream, rootType, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
            unmarshal_VkSamplerYcbcrConversionInfo(
                vkStream, rootType,
                reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
            unmarshal_VkBindImagePlaneMemoryInfo(
                vkStream, rootType,
                reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
            unmarshal_VkImagePlaneMemoryRequirementsInfo(
                vkStream, rootType,
                reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
            unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
            unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
                vkStream, rootType,
                reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
            unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
            unmarshal_VkExternalImageFormatProperties(
                vkStream, rootType,
                reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
            unmarshal_VkPhysicalDeviceIDProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
            unmarshal_VkExternalMemoryImageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
            unmarshal_VkExternalMemoryBufferCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
            unmarshal_VkExportMemoryAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
            unmarshal_VkExportFenceCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
            unmarshal_VkExportSemaphoreCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
            unmarshal_VkPhysicalDeviceMaintenance3Properties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_VERSION_1_2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
            unmarshal_VkPhysicalDeviceVulkan11Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
            unmarshal_VkPhysicalDeviceVulkan11Properties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
            unmarshal_VkPhysicalDeviceVulkan12Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
            unmarshal_VkPhysicalDeviceVulkan12Properties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
            unmarshal_VkImageFormatListCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
            unmarshal_VkPhysicalDevice8BitStorageFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
            unmarshal_VkPhysicalDeviceDriverProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
            unmarshal_VkPhysicalDeviceFloatControlsProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
            unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
            unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
            unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
            unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
            unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
                vkStream, rootType,
                reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
            unmarshal_VkSubpassDescriptionDepthStencilResolve(
                vkStream, rootType,
                reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
            unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
            unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
            unmarshal_VkImageStencilUsageCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
            unmarshal_VkSamplerReductionModeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
            unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
            unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
            unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
            unmarshal_VkFramebufferAttachmentsCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
            unmarshal_VkRenderPassAttachmentBeginInfo(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
            unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
            unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
            unmarshal_VkAttachmentReferenceStencilLayout(
                vkStream, rootType,
                reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
            unmarshal_VkAttachmentDescriptionStencilLayout(
                vkStream, rootType,
                reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
            unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
            unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
            unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
            unmarshal_VkSemaphoreTypeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
            unmarshal_VkTimelineSemaphoreSubmitInfo(
                vkStream, rootType,
                reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
            unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
            unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
            unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
                vkStream, rootType,
                reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_VERSION_1_3
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
            unmarshal_VkPhysicalDeviceVulkan13Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
            unmarshal_VkPhysicalDeviceVulkan13Properties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
            unmarshal_VkPipelineCreationFeedbackCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
            unmarshal_VkPhysicalDevicePrivateDataFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
            unmarshal_VkDevicePrivateDataCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
            unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
            unmarshal_VkMemoryBarrier2(vkStream, rootType,
                                       reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
            unmarshal_VkPhysicalDeviceSynchronization2Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
            unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
            unmarshal_VkPhysicalDeviceImageRobustnessFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
            unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
            unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
            unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
            unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
            unmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
            unmarshal_VkWriteDescriptorSetInlineUniformBlock(
                vkStream, rootType,
                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
            unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
            unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
            unmarshal_VkPipelineRenderingCreateInfo(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
            unmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
            unmarshal_VkCommandBufferInheritanceRenderingInfo(
                vkStream, rootType,
                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
            unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
            unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
            unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
            unmarshal_VkFormatProperties3(
                vkStream, rootType, reinterpret_cast<VkFormatProperties3*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
            unmarshal_VkPhysicalDeviceMaintenance4Features(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
            unmarshal_VkPhysicalDeviceMaintenance4Properties(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_swapchain
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
            unmarshal_VkImageSwapchainCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
            unmarshal_VkBindImageMemorySwapchainInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
            unmarshal_VkDeviceGroupPresentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
            unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_display_swapchain
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
            unmarshal_VkDisplayPresentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_video_queue
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
            unmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
            unmarshal_VkQueueFamilyVideoPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
            unmarshal_VkVideoProfileInfoKHR(
                vkStream, rootType, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
            unmarshal_VkVideoProfileListInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_queue
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
            unmarshal_VkVideoDecodeCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
            unmarshal_VkVideoDecodeUsageInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_h264
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
            unmarshal_VkVideoDecodeH264ProfileInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
            unmarshal_VkVideoDecodeH264CapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
            unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
            unmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
            unmarshal_VkVideoDecodeH264PictureInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
            unmarshal_VkVideoDecodeH264DpbSlotInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_dynamic_rendering
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
            unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
            unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
            unmarshal_VkAttachmentSampleCountInfoAMD(
                vkStream, rootType,
                reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
            unmarshal_VkMultiviewPerViewAttributesInfoNVX(
                vkStream, rootType,
                reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
            unmarshal_VkImportMemoryWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
            unmarshal_VkExportMemoryWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_memory_fd
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
            unmarshal_VkImportMemoryFdInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
            unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_semaphore_win32
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
            unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
            unmarshal_VkD3D12FenceSubmitInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_push_descriptor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_incremental_present
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
            unmarshal_VkPresentRegionsKHR(
                vkStream, rootType, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_shared_presentable_image
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
            unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_external_fence_win32
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
            unmarshal_VkExportFenceWin32HandleInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_performance_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
            unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
            unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
            unmarshal_VkPerformanceQuerySubmitInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_portability_subset
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
            unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_KHR_shader_clock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_video_decode_h265
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
            unmarshal_VkVideoDecodeH265ProfileInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
            unmarshal_VkVideoDecodeH265CapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
            unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
            unmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
            unmarshal_VkVideoDecodeH265PictureInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
            unmarshal_VkVideoDecodeH265DpbSlotInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_global_priority
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
            unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
            unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_fragment_shading_rate
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
            unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
            unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_surface_protected_capabilities
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
            unmarshal_VkSurfaceProtectedCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_present_wait
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
            unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
            unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_pipeline_library
        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
            unmarshal_VkPipelineLibraryCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_present_id
        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
            unmarshal_VkPresentIdKHR(vkStream, rootType,
                                     reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
            unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_video_encode_queue
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
            unmarshal_VkVideoEncodeCapabilitiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
            unmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
            unmarshal_VkVideoEncodeUsageInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
            unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
            unmarshal_VkVideoEncodeRateControlInfoKHR(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_KHR_synchronization2
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
            unmarshal_VkQueueFamilyCheckpointProperties2NV(
                vkStream, rootType,
                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_fragment_shader_barycentric
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_maintenance1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_position_fetch
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_ANDROID_native_buffer
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
            unmarshal_VkNativeBufferANDROID(
                vkStream, rootType, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_debug_report
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
            unmarshal_VkDebugReportCallbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_rasterization_order
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
            unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
            unmarshal_VkDedicatedAllocationImageCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
            unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
            unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_transform_feedback
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_video_encode_h264
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
            unmarshal_VkVideoEncodeH264CapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
            unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
            unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
            unmarshal_VkVideoEncodeH264VclFrameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
            unmarshal_VkVideoEncodeH264ProfileInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
            unmarshal_VkVideoEncodeH264RateControlInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
            unmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_EXT_video_encode_h265
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
            unmarshal_VkVideoEncodeH265CapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
            unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
            unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
            unmarshal_VkVideoEncodeH265VclFrameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
            unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
            unmarshal_VkVideoEncodeH265ProfileInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
            unmarshal_VkVideoEncodeH265RateControlInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
            unmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_AMD_texture_gather_bias_lod
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
            unmarshal_VkTextureLODGatherFormatPropertiesAMD(
                vkStream, rootType,
                reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_corner_sampled_image
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_external_memory
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
            unmarshal_VkExternalMemoryImageCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
            unmarshal_VkExportMemoryAllocateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_external_memory_win32
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
            unmarshal_VkImportMemoryWin32HandleInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
            unmarshal_VkExportMemoryWin32HandleInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_win32_keyed_mutex
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
            unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_flags
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
            unmarshal_VkValidationFlagsEXT(
                vkStream, rootType, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_astc_decode_mode
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
            unmarshal_VkImageViewASTCDecodeModeEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_robustness
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRobustnessCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_conditional_rendering
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
            unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_clip_space_w_scaling
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_display_control
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
            unmarshal_VkSwapchainCounterCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_GOOGLE_display_timing
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
            unmarshal_VkPresentTimesInfoGOOGLE(
                vkStream, rootType,
                reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NVX_multiview_per_view_attributes
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
            unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_viewport_swizzle
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_conservative_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_depth_clip_enable
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_debug_utils
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
            unmarshal_VkDebugUtilsObjectNameInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
            unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
            unmarshal_VkAndroidHardwareBufferUsageANDROID(
                vkStream, rootType,
                reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
            unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
                vkStream, rootType,
                reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
            unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
                vkStream, rootType,
                reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
            unmarshal_VkExternalFormatANDROID(
                vkStream, rootType,
                reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
            unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
                vkStream, rootType,
                reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_sample_locations
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
            unmarshal_VkSampleLocationsInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
            unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_blend_operation_advanced
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_fragment_coverage_to_color
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_framebuffer_mixed_samples
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shader_sm_builtins
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_drm_format_modifier
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
            unmarshal_VkDrmFormatModifierPropertiesListEXT(
                vkStream, rootType,
                reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
            unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
            unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
            unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
            unmarshal_VkDrmFormatModifierPropertiesList2EXT(
                vkStream, rootType,
                reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_cache
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
            unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shading_rate_image
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
            unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
                vkStream, rootType,
                reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_representative_fragment_test
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_filter_cubic
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
            unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
            unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_external_memory_host
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
            unmarshal_VkImportMemoryHostPointerInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_pipeline_compiler_control
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
            unmarshal_VkPipelineCompilerControlCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
            unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_memory_overallocation_behavior
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
            unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_vertex_attribute_divisor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_GGP_frame_token
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
            unmarshal_VkPresentFrameTokenGGP(
                vkStream, rootType, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_compute_shader_derivatives
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_mesh_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_shader_image_footprint
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_scissor_exclusive
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
            unmarshal_VkQueueFamilyCheckpointPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_INTEL_shader_integer_functions2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
            unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_INTEL_performance_query
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
            unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
                vkStream, rootType,
                reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pci_bus_info
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_display_native_hdr
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
            unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
                vkStream, rootType,
                reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
            unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_fragment_density_map
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
                    unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension_out));
                    break;
                }
                case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
                    unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension_out));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    unmarshal_VkImportColorBufferGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
                    break;
                }
                default: {
                    unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                            structExtension_out));
                    break;
                }
            }
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
                    unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
                            structExtension_out));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    unmarshal_VkCreateBlobGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<VkCreateBlobGOOGLE*>(structExtension_out));
                    break;
                }
                default: {
                    unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
                            structExtension_out));
                    break;
                }
            }
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
            switch (rootType) {
                case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
                    unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension_out));
                    break;
                }
                case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
                    unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension_out));
                    break;
                }
                case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
                    unmarshal_VkImportBufferGOOGLE(
                        vkStream, rootType,
                        reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
                    break;
                }
                default: {
                    unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
                        vkStream, rootType,
                        reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
                            structExtension_out));
                    break;
                }
            }
            break;
        }
#endif
#ifdef VK_AMD_shader_core_properties2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
            unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_device_coherent_memory
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
            unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_image_atomic_int64
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_memory_budget
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_memory_priority
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
            unmarshal_VkMemoryPriorityAllocateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_buffer_device_address
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
            unmarshal_VkBufferDeviceAddressCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_validation_features
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
            unmarshal_VkValidationFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_cooperative_matrix
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_coverage_reduction_mode
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_fragment_shader_interlock
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_ycbcr_image_arrays
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_provoking_vertex
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
            unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
            unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
            unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_line_rasterization
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_atomic_float
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_index_type_uint8
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_atomic_float2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_surface_maintenance1
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
            unmarshal_VkSurfacePresentModeEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
            unmarshal_VkSurfacePresentScalingCapabilitiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
            unmarshal_VkSurfacePresentModeCompatibilityEXT(
                vkStream, rootType,
                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_swapchain_maintenance1
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
            unmarshal_VkSwapchainPresentFenceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
            unmarshal_VkSwapchainPresentModesCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
            unmarshal_VkSwapchainPresentModeInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
            unmarshal_VkSwapchainPresentScalingCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_generated_commands
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
            unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_inherited_viewport_scissor
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
            unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_texel_buffer_alignment
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_render_pass_transform
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
            unmarshal_VkRenderPassTransformBeginInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
            unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_device_memory_report
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
            unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_robustness2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_custom_border_color
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
            unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_present_barrier
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
            unmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
            unmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
                vkStream, rootType,
                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
            unmarshal_VkSwapchainPresentBarrierCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_device_diagnostics_config
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
            unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_low_latency
        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
            unmarshal_VkQueryLowLatencySupportNV(
                vkStream, rootType,
                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_metal_objects
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
            unmarshal_VkExportMetalObjectCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
            unmarshal_VkExportMetalDeviceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
            unmarshal_VkExportMetalCommandQueueInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
            unmarshal_VkExportMetalBufferInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
            unmarshal_VkImportMetalBufferInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
            unmarshal_VkExportMetalTextureInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
            unmarshal_VkImportMetalTextureInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
            unmarshal_VkExportMetalIOSurfaceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
            unmarshal_VkImportMetalIOSurfaceInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
            unmarshal_VkExportMetalSharedEventInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
            unmarshal_VkImportMetalSharedEventInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
            unmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
                vkStream, rootType,
                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
            unmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_graphics_pipeline_library
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
            unmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
            unmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_fragment_shading_rate_enums
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
            unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing_motion_blur
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
            unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
                vkStream, rootType,
                reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
            unmarshal_VkAccelerationStructureMotionInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_fragment_density_map2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_rotated_copy_commands
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
            unmarshal_VkCopyCommandTransformInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_compression_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
            unmarshal_VkImageCompressionControlEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
            unmarshal_VkImageCompressionPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_4444_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
            unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_device_fault
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceFaultFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_ARM_rasterization_order_attachment_access
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_rgba10x6_formats
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_VALVE_mutable_descriptor_type
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
            unmarshal_VkMutableDescriptorTypeCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_physical_device_drm
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceDrmPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_device_address_binding_report
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
            unmarshal_VkDeviceAddressBindingCallbackDataEXT(
                vkStream, rootType,
                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_depth_clip_control
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
            unmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_primitive_topology_list_restart
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_FUCHSIA_external_memory
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
            unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
            unmarshal_VkImportMemoryBufferCollectionFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
            unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
            unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
                vkStream, rootType,
                reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_HUAWEI_subpass_shading
        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
            unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
            unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
            unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_HUAWEI_invocation_mask
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
            unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_external_memory_rdma
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
            unmarshal_VkSubpassResolvePerformanceQueryEXT(
                vkStream, rootType,
                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
            unmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_color_write_enable
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
            unmarshal_VkPipelineColorWriteCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_primitives_generated_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
            unmarshal_VkImportColorBufferGOOGLE(
                vkStream, rootType,
                reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
            unmarshal_VkImportBufferGOOGLE(
                vkStream, rootType, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE: {
            unmarshal_VkCreateBlobGOOGLE(
                vkStream, rootType, reinterpret_cast<VkCreateBlobGOOGLE*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_view_min_lod
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
            unmarshal_VkImageViewMinLodCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_multi_draw
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_2d_view_of_3d
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_tile_image
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
            unmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
                vkStream, rootType,
                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_displacement_micromap
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
            unmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
                vkStream, rootType,
                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
                    structExtension_out));
            break;
        }
#endif  // VK_ENABLE_BETA_EXTENSIONS
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
            unmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
            unmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_border_color_swizzle
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
            unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pageable_device_local_memory
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_ARM_shader_core_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
            unmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_sliced_view_of_3d
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
            unmarshal_VkImageViewSlicedCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
            unmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_depth_clamp_zero_one
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_non_seamless_cube_map
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_fragment_density_map_offset
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
            unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
            unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
            unmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_copy_memory_indirect
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_memory_decompression
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_linear_color_attachment
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_image_compression_control_swapchain
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_image_processing
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
            unmarshal_VkImageViewSampleWeightCreateInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
            unmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
            unmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_subpass_merge_feedback
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
            unmarshal_VkRenderPassCreationControlEXT(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
            unmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
            unmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_LUNARG_direct_driver_loading
        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
            unmarshal_VkDirectDriverLoadingListLUNARG(
                vkStream, rootType,
                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_module_identifier
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
            unmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
                vkStream, rootType,
                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_optical_flow
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
            unmarshal_VkOpticalFlowImageFormatInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
            unmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
                vkStream, rootType,
                reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_legacy_dithering
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_protected_access
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_shader_object
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_tile_properties
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
            unmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_SEC_amigo_profiling
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
            unmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
            unmarshal_VkAmigoProfilingSubmitInfoSEC(
                vkStream, rootType,
                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_multiview_per_view_viewports
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
            unmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
            unmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
            unmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_ARM_shader_core_builtins
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
            unmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
            unmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_pipeline_library_group_handles
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
            unmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
            unmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
            unmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
                vkStream, rootType,
                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
            unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
                vkStream, rootType,
                reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                    structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
            unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
                    structExtension_out));
            break;
        }
#endif
#ifdef VK_KHR_ray_query
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
            unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
            break;
        }
#endif
#ifdef VK_EXT_mesh_shader
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
            unmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
            break;
        }
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
            unmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
                vkStream, rootType,
                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
            break;
        }
#endif
        default: {
            // fatal; the switch is only taken if the extension struct is known
            abort();
        }
    }
}

const char* api_opcode_to_string(const uint32_t opcode) {
    switch (opcode) {
#ifdef VK_VERSION_1_0
        case OP_vkCreateInstance: {
            return "OP_vkCreateInstance";
        }
        case OP_vkDestroyInstance: {
            return "OP_vkDestroyInstance";
        }
        case OP_vkEnumeratePhysicalDevices: {
            return "OP_vkEnumeratePhysicalDevices";
        }
        case OP_vkGetPhysicalDeviceFeatures: {
            return "OP_vkGetPhysicalDeviceFeatures";
        }
        case OP_vkGetPhysicalDeviceFormatProperties: {
            return "OP_vkGetPhysicalDeviceFormatProperties";
        }
        case OP_vkGetPhysicalDeviceImageFormatProperties: {
            return "OP_vkGetPhysicalDeviceImageFormatProperties";
        }
        case OP_vkGetPhysicalDeviceProperties: {
            return "OP_vkGetPhysicalDeviceProperties";
        }
        case OP_vkGetPhysicalDeviceQueueFamilyProperties: {
            return "OP_vkGetPhysicalDeviceQueueFamilyProperties";
        }
        case OP_vkGetPhysicalDeviceMemoryProperties: {
            return "OP_vkGetPhysicalDeviceMemoryProperties";
        }
        case OP_vkGetInstanceProcAddr: {
            return "OP_vkGetInstanceProcAddr";
        }
        case OP_vkGetDeviceProcAddr: {
            return "OP_vkGetDeviceProcAddr";
        }
        case OP_vkCreateDevice: {
            return "OP_vkCreateDevice";
        }
        case OP_vkDestroyDevice: {
            return "OP_vkDestroyDevice";
        }
        case OP_vkEnumerateInstanceExtensionProperties: {
            return "OP_vkEnumerateInstanceExtensionProperties";
        }
        case OP_vkEnumerateDeviceExtensionProperties: {
            return "OP_vkEnumerateDeviceExtensionProperties";
        }
        case OP_vkEnumerateInstanceLayerProperties: {
            return "OP_vkEnumerateInstanceLayerProperties";
        }
        case OP_vkEnumerateDeviceLayerProperties: {
            return "OP_vkEnumerateDeviceLayerProperties";
        }
        case OP_vkGetDeviceQueue: {
            return "OP_vkGetDeviceQueue";
        }
        case OP_vkQueueSubmit: {
            return "OP_vkQueueSubmit";
        }
        case OP_vkQueueWaitIdle: {
            return "OP_vkQueueWaitIdle";
        }
        case OP_vkDeviceWaitIdle: {
            return "OP_vkDeviceWaitIdle";
        }
        case OP_vkAllocateMemory: {
            return "OP_vkAllocateMemory";
        }
        case OP_vkFreeMemory: {
            return "OP_vkFreeMemory";
        }
        case OP_vkMapMemory: {
            return "OP_vkMapMemory";
        }
        case OP_vkUnmapMemory: {
            return "OP_vkUnmapMemory";
        }
        case OP_vkFlushMappedMemoryRanges: {
            return "OP_vkFlushMappedMemoryRanges";
        }
        case OP_vkInvalidateMappedMemoryRanges: {
            return "OP_vkInvalidateMappedMemoryRanges";
        }
        case OP_vkGetDeviceMemoryCommitment: {
            return "OP_vkGetDeviceMemoryCommitment";
        }
        case OP_vkBindBufferMemory: {
            return "OP_vkBindBufferMemory";
        }
        case OP_vkBindImageMemory: {
            return "OP_vkBindImageMemory";
        }
        case OP_vkGetBufferMemoryRequirements: {
            return "OP_vkGetBufferMemoryRequirements";
        }
        case OP_vkGetImageMemoryRequirements: {
            return "OP_vkGetImageMemoryRequirements";
        }
        case OP_vkGetImageSparseMemoryRequirements: {
            return "OP_vkGetImageSparseMemoryRequirements";
        }
        case OP_vkGetPhysicalDeviceSparseImageFormatProperties: {
            return "OP_vkGetPhysicalDeviceSparseImageFormatProperties";
        }
        case OP_vkQueueBindSparse: {
            return "OP_vkQueueBindSparse";
        }
        case OP_vkCreateFence: {
            return "OP_vkCreateFence";
        }
        case OP_vkDestroyFence: {
            return "OP_vkDestroyFence";
        }
        case OP_vkResetFences: {
            return "OP_vkResetFences";
        }
        case OP_vkGetFenceStatus: {
            return "OP_vkGetFenceStatus";
        }
        case OP_vkWaitForFences: {
            return "OP_vkWaitForFences";
        }
        case OP_vkCreateSemaphore: {
            return "OP_vkCreateSemaphore";
        }
        case OP_vkDestroySemaphore: {
            return "OP_vkDestroySemaphore";
        }
        case OP_vkCreateEvent: {
            return "OP_vkCreateEvent";
        }
        case OP_vkDestroyEvent: {
            return "OP_vkDestroyEvent";
        }
        case OP_vkGetEventStatus: {
            return "OP_vkGetEventStatus";
        }
        case OP_vkSetEvent: {
            return "OP_vkSetEvent";
        }
        case OP_vkResetEvent: {
            return "OP_vkResetEvent";
        }
        case OP_vkCreateQueryPool: {
            return "OP_vkCreateQueryPool";
        }
        case OP_vkDestroyQueryPool: {
            return "OP_vkDestroyQueryPool";
        }
        case OP_vkGetQueryPoolResults: {
            return "OP_vkGetQueryPoolResults";
        }
        case OP_vkCreateBuffer: {
            return "OP_vkCreateBuffer";
        }
        case OP_vkDestroyBuffer: {
            return "OP_vkDestroyBuffer";
        }
        case OP_vkCreateBufferView: {
            return "OP_vkCreateBufferView";
        }
        case OP_vkDestroyBufferView: {
            return "OP_vkDestroyBufferView";
        }
        case OP_vkCreateImage: {
            return "OP_vkCreateImage";
        }
        case OP_vkDestroyImage: {
            return "OP_vkDestroyImage";
        }
        case OP_vkGetImageSubresourceLayout: {
            return "OP_vkGetImageSubresourceLayout";
        }
        case OP_vkCreateImageView: {
            return "OP_vkCreateImageView";
        }
        case OP_vkDestroyImageView: {
            return "OP_vkDestroyImageView";
        }
        case OP_vkCreateShaderModule: {
            return "OP_vkCreateShaderModule";
        }
        case OP_vkDestroyShaderModule: {
            return "OP_vkDestroyShaderModule";
        }
        case OP_vkCreatePipelineCache: {
            return "OP_vkCreatePipelineCache";
        }
        case OP_vkDestroyPipelineCache: {
            return "OP_vkDestroyPipelineCache";
        }
        case OP_vkGetPipelineCacheData: {
            return "OP_vkGetPipelineCacheData";
        }
        case OP_vkMergePipelineCaches: {
            return "OP_vkMergePipelineCaches";
        }
        case OP_vkCreateGraphicsPipelines: {
            return "OP_vkCreateGraphicsPipelines";
        }
        case OP_vkCreateComputePipelines: {
            return "OP_vkCreateComputePipelines";
        }
        case OP_vkDestroyPipeline: {
            return "OP_vkDestroyPipeline";
        }
        case OP_vkCreatePipelineLayout: {
            return "OP_vkCreatePipelineLayout";
        }
        case OP_vkDestroyPipelineLayout: {
            return "OP_vkDestroyPipelineLayout";
        }
        case OP_vkCreateSampler: {
            return "OP_vkCreateSampler";
        }
        case OP_vkDestroySampler: {
            return "OP_vkDestroySampler";
        }
        case OP_vkCreateDescriptorSetLayout: {
            return "OP_vkCreateDescriptorSetLayout";
        }
        case OP_vkDestroyDescriptorSetLayout: {
            return "OP_vkDestroyDescriptorSetLayout";
        }
        case OP_vkCreateDescriptorPool: {
            return "OP_vkCreateDescriptorPool";
        }
        case OP_vkDestroyDescriptorPool: {
            return "OP_vkDestroyDescriptorPool";
        }
        case OP_vkResetDescriptorPool: {
            return "OP_vkResetDescriptorPool";
        }
        case OP_vkAllocateDescriptorSets: {
            return "OP_vkAllocateDescriptorSets";
        }
        case OP_vkFreeDescriptorSets: {
            return "OP_vkFreeDescriptorSets";
        }
        case OP_vkUpdateDescriptorSets: {
            return "OP_vkUpdateDescriptorSets";
        }
        case OP_vkCreateFramebuffer: {
            return "OP_vkCreateFramebuffer";
        }
        case OP_vkDestroyFramebuffer: {
            return "OP_vkDestroyFramebuffer";
        }
        case OP_vkCreateRenderPass: {
            return "OP_vkCreateRenderPass";
        }
        case OP_vkDestroyRenderPass: {
            return "OP_vkDestroyRenderPass";
        }
        case OP_vkGetRenderAreaGranularity: {
            return "OP_vkGetRenderAreaGranularity";
        }
        case OP_vkCreateCommandPool: {
            return "OP_vkCreateCommandPool";
        }
        case OP_vkDestroyCommandPool: {
            return "OP_vkDestroyCommandPool";
        }
        case OP_vkResetCommandPool: {
            return "OP_vkResetCommandPool";
        }
        case OP_vkAllocateCommandBuffers: {
            return "OP_vkAllocateCommandBuffers";
        }
        case OP_vkFreeCommandBuffers: {
            return "OP_vkFreeCommandBuffers";
        }
        case OP_vkBeginCommandBuffer: {
            return "OP_vkBeginCommandBuffer";
        }
        case OP_vkEndCommandBuffer: {
            return "OP_vkEndCommandBuffer";
        }
        case OP_vkResetCommandBuffer: {
            return "OP_vkResetCommandBuffer";
        }
        case OP_vkCmdBindPipeline: {
            return "OP_vkCmdBindPipeline";
        }
        case OP_vkCmdSetViewport: {
            return "OP_vkCmdSetViewport";
        }
        case OP_vkCmdSetScissor: {
            return "OP_vkCmdSetScissor";
        }
        case OP_vkCmdSetLineWidth: {
            return "OP_vkCmdSetLineWidth";
        }
        case OP_vkCmdSetDepthBias: {
            return "OP_vkCmdSetDepthBias";
        }
        case OP_vkCmdSetBlendConstants: {
            return "OP_vkCmdSetBlendConstants";
        }
        case OP_vkCmdSetDepthBounds: {
            return "OP_vkCmdSetDepthBounds";
        }
        case OP_vkCmdSetStencilCompareMask: {
            return "OP_vkCmdSetStencilCompareMask";
        }
        case OP_vkCmdSetStencilWriteMask: {
            return "OP_vkCmdSetStencilWriteMask";
        }
        case OP_vkCmdSetStencilReference: {
            return "OP_vkCmdSetStencilReference";
        }
        case OP_vkCmdBindDescriptorSets: {
            return "OP_vkCmdBindDescriptorSets";
        }
        case OP_vkCmdBindIndexBuffer: {
            return "OP_vkCmdBindIndexBuffer";
        }
        case OP_vkCmdBindVertexBuffers: {
            return "OP_vkCmdBindVertexBuffers";
        }
        case OP_vkCmdDraw: {
            return "OP_vkCmdDraw";
        }
        case OP_vkCmdDrawIndexed: {
            return "OP_vkCmdDrawIndexed";
        }
        case OP_vkCmdDrawIndirect: {
            return "OP_vkCmdDrawIndirect";
        }
        case OP_vkCmdDrawIndexedIndirect: {
            return "OP_vkCmdDrawIndexedIndirect";
        }
        case OP_vkCmdDispatch: {
            return "OP_vkCmdDispatch";
        }
        case OP_vkCmdDispatchIndirect: {
            return "OP_vkCmdDispatchIndirect";
        }
        case OP_vkCmdCopyBuffer: {
            return "OP_vkCmdCopyBuffer";
        }
        case OP_vkCmdCopyImage: {
            return "OP_vkCmdCopyImage";
        }
        case OP_vkCmdBlitImage: {
            return "OP_vkCmdBlitImage";
        }
        case OP_vkCmdCopyBufferToImage: {
            return "OP_vkCmdCopyBufferToImage";
        }
        case OP_vkCmdCopyImageToBuffer: {
            return "OP_vkCmdCopyImageToBuffer";
        }
        case OP_vkCmdUpdateBuffer: {
            return "OP_vkCmdUpdateBuffer";
        }
        case OP_vkCmdFillBuffer: {
            return "OP_vkCmdFillBuffer";
        }
        case OP_vkCmdClearColorImage: {
            return "OP_vkCmdClearColorImage";
        }
        case OP_vkCmdClearDepthStencilImage: {
            return "OP_vkCmdClearDepthStencilImage";
        }
        case OP_vkCmdClearAttachments: {
            return "OP_vkCmdClearAttachments";
        }
        case OP_vkCmdResolveImage: {
            return "OP_vkCmdResolveImage";
        }
        case OP_vkCmdSetEvent: {
            return "OP_vkCmdSetEvent";
        }
        case OP_vkCmdResetEvent: {
            return "OP_vkCmdResetEvent";
        }
        case OP_vkCmdWaitEvents: {
            return "OP_vkCmdWaitEvents";
        }
        case OP_vkCmdPipelineBarrier: {
            return "OP_vkCmdPipelineBarrier";
        }
        case OP_vkCmdBeginQuery: {
            return "OP_vkCmdBeginQuery";
        }
        case OP_vkCmdEndQuery: {
            return "OP_vkCmdEndQuery";
        }
        case OP_vkCmdResetQueryPool: {
            return "OP_vkCmdResetQueryPool";
        }
        case OP_vkCmdWriteTimestamp: {
            return "OP_vkCmdWriteTimestamp";
        }
        case OP_vkCmdCopyQueryPoolResults: {
            return "OP_vkCmdCopyQueryPoolResults";
        }
        case OP_vkCmdPushConstants: {
            return "OP_vkCmdPushConstants";
        }
        case OP_vkCmdBeginRenderPass: {
            return "OP_vkCmdBeginRenderPass";
        }
        case OP_vkCmdNextSubpass: {
            return "OP_vkCmdNextSubpass";
        }
        case OP_vkCmdEndRenderPass: {
            return "OP_vkCmdEndRenderPass";
        }
        case OP_vkCmdExecuteCommands: {
            return "OP_vkCmdExecuteCommands";
        }
#endif
#ifdef VK_VERSION_1_1
        case OP_vkEnumerateInstanceVersion: {
            return "OP_vkEnumerateInstanceVersion";
        }
        case OP_vkBindBufferMemory2: {
            return "OP_vkBindBufferMemory2";
        }
        case OP_vkBindImageMemory2: {
            return "OP_vkBindImageMemory2";
        }
        case OP_vkGetDeviceGroupPeerMemoryFeatures: {
            return "OP_vkGetDeviceGroupPeerMemoryFeatures";
        }
        case OP_vkCmdSetDeviceMask: {
            return "OP_vkCmdSetDeviceMask";
        }
        case OP_vkCmdDispatchBase: {
            return "OP_vkCmdDispatchBase";
        }
        case OP_vkEnumeratePhysicalDeviceGroups: {
            return "OP_vkEnumeratePhysicalDeviceGroups";
        }
        case OP_vkGetImageMemoryRequirements2: {
            return "OP_vkGetImageMemoryRequirements2";
        }
        case OP_vkGetBufferMemoryRequirements2: {
            return "OP_vkGetBufferMemoryRequirements2";
        }
        case OP_vkGetImageSparseMemoryRequirements2: {
            return "OP_vkGetImageSparseMemoryRequirements2";
        }
        case OP_vkGetPhysicalDeviceFeatures2: {
            return "OP_vkGetPhysicalDeviceFeatures2";
        }
        case OP_vkGetPhysicalDeviceProperties2: {
            return "OP_vkGetPhysicalDeviceProperties2";
        }
        case OP_vkGetPhysicalDeviceFormatProperties2: {
            return "OP_vkGetPhysicalDeviceFormatProperties2";
        }
        case OP_vkGetPhysicalDeviceImageFormatProperties2: {
            return "OP_vkGetPhysicalDeviceImageFormatProperties2";
        }
        case OP_vkGetPhysicalDeviceQueueFamilyProperties2: {
            return "OP_vkGetPhysicalDeviceQueueFamilyProperties2";
        }
        case OP_vkGetPhysicalDeviceMemoryProperties2: {
            return "OP_vkGetPhysicalDeviceMemoryProperties2";
        }
        case OP_vkGetPhysicalDeviceSparseImageFormatProperties2: {
            return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2";
        }
        case OP_vkTrimCommandPool: {
            return "OP_vkTrimCommandPool";
        }
        case OP_vkGetDeviceQueue2: {
            return "OP_vkGetDeviceQueue2";
        }
        case OP_vkCreateSamplerYcbcrConversion: {
            return "OP_vkCreateSamplerYcbcrConversion";
        }
        case OP_vkDestroySamplerYcbcrConversion: {
            return "OP_vkDestroySamplerYcbcrConversion";
        }
        case OP_vkCreateDescriptorUpdateTemplate: {
            return "OP_vkCreateDescriptorUpdateTemplate";
        }
        case OP_vkDestroyDescriptorUpdateTemplate: {
            return "OP_vkDestroyDescriptorUpdateTemplate";
        }
        case OP_vkUpdateDescriptorSetWithTemplate: {
            return "OP_vkUpdateDescriptorSetWithTemplate";
        }
        case OP_vkGetPhysicalDeviceExternalBufferProperties: {
            return "OP_vkGetPhysicalDeviceExternalBufferProperties";
        }
        case OP_vkGetPhysicalDeviceExternalFenceProperties: {
            return "OP_vkGetPhysicalDeviceExternalFenceProperties";
        }
        case OP_vkGetPhysicalDeviceExternalSemaphoreProperties: {
            return "OP_vkGetPhysicalDeviceExternalSemaphoreProperties";
        }
        case OP_vkGetDescriptorSetLayoutSupport: {
            return "OP_vkGetDescriptorSetLayoutSupport";
        }
#endif
#ifdef VK_KHR_surface
        case OP_vkDestroySurfaceKHR: {
            return "OP_vkDestroySurfaceKHR";
        }
        case OP_vkGetPhysicalDeviceSurfaceSupportKHR: {
            return "OP_vkGetPhysicalDeviceSurfaceSupportKHR";
        }
        case OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR: {
            return "OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR";
        }
        case OP_vkGetPhysicalDeviceSurfaceFormatsKHR: {
            return "OP_vkGetPhysicalDeviceSurfaceFormatsKHR";
        }
        case OP_vkGetPhysicalDeviceSurfacePresentModesKHR: {
            return "OP_vkGetPhysicalDeviceSurfacePresentModesKHR";
        }
#endif
#ifdef VK_KHR_swapchain
        case OP_vkCreateSwapchainKHR: {
            return "OP_vkCreateSwapchainKHR";
        }
        case OP_vkDestroySwapchainKHR: {
            return "OP_vkDestroySwapchainKHR";
        }
        case OP_vkGetSwapchainImagesKHR: {
            return "OP_vkGetSwapchainImagesKHR";
        }
        case OP_vkAcquireNextImageKHR: {
            return "OP_vkAcquireNextImageKHR";
        }
        case OP_vkQueuePresentKHR: {
            return "OP_vkQueuePresentKHR";
        }
        case OP_vkGetDeviceGroupPresentCapabilitiesKHR: {
            return "OP_vkGetDeviceGroupPresentCapabilitiesKHR";
        }
        case OP_vkGetDeviceGroupSurfacePresentModesKHR: {
            return "OP_vkGetDeviceGroupSurfacePresentModesKHR";
        }
        case OP_vkGetPhysicalDevicePresentRectanglesKHR: {
            return "OP_vkGetPhysicalDevicePresentRectanglesKHR";
        }
        case OP_vkAcquireNextImage2KHR: {
            return "OP_vkAcquireNextImage2KHR";
        }
#endif
#ifdef VK_KHR_display
        case OP_vkGetPhysicalDeviceDisplayPropertiesKHR: {
            return "OP_vkGetPhysicalDeviceDisplayPropertiesKHR";
        }
        case OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR: {
            return "OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR";
        }
        case OP_vkGetDisplayPlaneSupportedDisplaysKHR: {
            return "OP_vkGetDisplayPlaneSupportedDisplaysKHR";
        }
        case OP_vkGetDisplayModePropertiesKHR: {
            return "OP_vkGetDisplayModePropertiesKHR";
        }
        case OP_vkCreateDisplayModeKHR: {
            return "OP_vkCreateDisplayModeKHR";
        }
        case OP_vkGetDisplayPlaneCapabilitiesKHR: {
            return "OP_vkGetDisplayPlaneCapabilitiesKHR";
        }
        case OP_vkCreateDisplayPlaneSurfaceKHR: {
            return "OP_vkCreateDisplayPlaneSurfaceKHR";
        }
#endif
#ifdef VK_KHR_display_swapchain
        case OP_vkCreateSharedSwapchainsKHR: {
            return "OP_vkCreateSharedSwapchainsKHR";
        }
#endif
#ifdef VK_KHR_xlib_surface
        case OP_vkCreateXlibSurfaceKHR: {
            return "OP_vkCreateXlibSurfaceKHR";
        }
        case OP_vkGetPhysicalDeviceXlibPresentationSupportKHR: {
            return "OP_vkGetPhysicalDeviceXlibPresentationSupportKHR";
        }
#endif
#ifdef VK_KHR_xcb_surface
        case OP_vkCreateXcbSurfaceKHR: {
            return "OP_vkCreateXcbSurfaceKHR";
        }
        case OP_vkGetPhysicalDeviceXcbPresentationSupportKHR: {
            return "OP_vkGetPhysicalDeviceXcbPresentationSupportKHR";
        }
#endif
#ifdef VK_KHR_wayland_surface
        case OP_vkCreateWaylandSurfaceKHR: {
            return "OP_vkCreateWaylandSurfaceKHR";
        }
        case OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR: {
            return "OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR";
        }
#endif
#ifdef VK_KHR_android_surface
        case OP_vkCreateAndroidSurfaceKHR: {
            return "OP_vkCreateAndroidSurfaceKHR";
        }
#endif
#ifdef VK_KHR_win32_surface
        case OP_vkCreateWin32SurfaceKHR: {
            return "OP_vkCreateWin32SurfaceKHR";
        }
        case OP_vkGetPhysicalDeviceWin32PresentationSupportKHR: {
            return "OP_vkGetPhysicalDeviceWin32PresentationSupportKHR";
        }
#endif
#ifdef VK_KHR_get_physical_device_properties2
        case OP_vkGetPhysicalDeviceFeatures2KHR: {
            return "OP_vkGetPhysicalDeviceFeatures2KHR";
        }
        case OP_vkGetPhysicalDeviceProperties2KHR: {
            return "OP_vkGetPhysicalDeviceProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceFormatProperties2KHR: {
            return "OP_vkGetPhysicalDeviceFormatProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceImageFormatProperties2KHR: {
            return "OP_vkGetPhysicalDeviceImageFormatProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR: {
            return "OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceMemoryProperties2KHR: {
            return "OP_vkGetPhysicalDeviceMemoryProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR: {
            return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR";
        }
#endif
#ifdef VK_KHR_device_group
        case OP_vkGetDeviceGroupPeerMemoryFeaturesKHR: {
            return "OP_vkGetDeviceGroupPeerMemoryFeaturesKHR";
        }
        case OP_vkCmdSetDeviceMaskKHR: {
            return "OP_vkCmdSetDeviceMaskKHR";
        }
        case OP_vkCmdDispatchBaseKHR: {
            return "OP_vkCmdDispatchBaseKHR";
        }
#endif
#ifdef VK_KHR_maintenance1
        case OP_vkTrimCommandPoolKHR: {
            return "OP_vkTrimCommandPoolKHR";
        }
#endif
#ifdef VK_KHR_device_group_creation
        case OP_vkEnumeratePhysicalDeviceGroupsKHR: {
            return "OP_vkEnumeratePhysicalDeviceGroupsKHR";
        }
#endif
#ifdef VK_KHR_external_memory_capabilities
        case OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR: {
            return "OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR";
        }
#endif
#ifdef VK_KHR_external_memory_win32
        case OP_vkGetMemoryWin32HandleKHR: {
            return "OP_vkGetMemoryWin32HandleKHR";
        }
        case OP_vkGetMemoryWin32HandlePropertiesKHR: {
            return "OP_vkGetMemoryWin32HandlePropertiesKHR";
        }
#endif
#ifdef VK_KHR_external_memory_fd
        case OP_vkGetMemoryFdKHR: {
            return "OP_vkGetMemoryFdKHR";
        }
        case OP_vkGetMemoryFdPropertiesKHR: {
            return "OP_vkGetMemoryFdPropertiesKHR";
        }
#endif
#ifdef VK_KHR_external_semaphore_capabilities
        case OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: {
            return "OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR";
        }
#endif
#ifdef VK_KHR_external_semaphore_win32
        case OP_vkImportSemaphoreWin32HandleKHR: {
            return "OP_vkImportSemaphoreWin32HandleKHR";
        }
        case OP_vkGetSemaphoreWin32HandleKHR: {
            return "OP_vkGetSemaphoreWin32HandleKHR";
        }
#endif
#ifdef VK_KHR_external_semaphore_fd
        case OP_vkImportSemaphoreFdKHR: {
            return "OP_vkImportSemaphoreFdKHR";
        }
        case OP_vkGetSemaphoreFdKHR: {
            return "OP_vkGetSemaphoreFdKHR";
        }
#endif
#ifdef VK_KHR_push_descriptor
        case OP_vkCmdPushDescriptorSetKHR: {
            return "OP_vkCmdPushDescriptorSetKHR";
        }
        case OP_vkCmdPushDescriptorSetWithTemplateKHR: {
            return "OP_vkCmdPushDescriptorSetWithTemplateKHR";
        }
#endif
#ifdef VK_KHR_descriptor_update_template
        case OP_vkCreateDescriptorUpdateTemplateKHR: {
            return "OP_vkCreateDescriptorUpdateTemplateKHR";
        }
        case OP_vkDestroyDescriptorUpdateTemplateKHR: {
            return "OP_vkDestroyDescriptorUpdateTemplateKHR";
        }
        case OP_vkUpdateDescriptorSetWithTemplateKHR: {
            return "OP_vkUpdateDescriptorSetWithTemplateKHR";
        }
#endif
#ifdef VK_KHR_create_renderpass2
        case OP_vkCreateRenderPass2KHR: {
            return "OP_vkCreateRenderPass2KHR";
        }
        case OP_vkCmdBeginRenderPass2KHR: {
            return "OP_vkCmdBeginRenderPass2KHR";
        }
        case OP_vkCmdNextSubpass2KHR: {
            return "OP_vkCmdNextSubpass2KHR";
        }
        case OP_vkCmdEndRenderPass2KHR: {
            return "OP_vkCmdEndRenderPass2KHR";
        }
#endif
#ifdef VK_KHR_shared_presentable_image
        case OP_vkGetSwapchainStatusKHR: {
            return "OP_vkGetSwapchainStatusKHR";
        }
#endif
#ifdef VK_KHR_external_fence_capabilities
        case OP_vkGetPhysicalDeviceExternalFencePropertiesKHR: {
            return "OP_vkGetPhysicalDeviceExternalFencePropertiesKHR";
        }
#endif
#ifdef VK_KHR_external_fence_win32
        case OP_vkImportFenceWin32HandleKHR: {
            return "OP_vkImportFenceWin32HandleKHR";
        }
        case OP_vkGetFenceWin32HandleKHR: {
            return "OP_vkGetFenceWin32HandleKHR";
        }
#endif
#ifdef VK_KHR_external_fence_fd
        case OP_vkImportFenceFdKHR: {
            return "OP_vkImportFenceFdKHR";
        }
        case OP_vkGetFenceFdKHR: {
            return "OP_vkGetFenceFdKHR";
        }
#endif
#ifdef VK_KHR_get_surface_capabilities2
        case OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR: {
            return "OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR";
        }
        case OP_vkGetPhysicalDeviceSurfaceFormats2KHR: {
            return "OP_vkGetPhysicalDeviceSurfaceFormats2KHR";
        }
#endif
#ifdef VK_KHR_get_display_properties2
        case OP_vkGetPhysicalDeviceDisplayProperties2KHR: {
            return "OP_vkGetPhysicalDeviceDisplayProperties2KHR";
        }
        case OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR: {
            return "OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR";
        }
        case OP_vkGetDisplayModeProperties2KHR: {
            return "OP_vkGetDisplayModeProperties2KHR";
        }
        case OP_vkGetDisplayPlaneCapabilities2KHR: {
            return "OP_vkGetDisplayPlaneCapabilities2KHR";
        }
#endif
#ifdef VK_KHR_get_memory_requirements2
        case OP_vkGetImageMemoryRequirements2KHR: {
            return "OP_vkGetImageMemoryRequirements2KHR";
        }
        case OP_vkGetBufferMemoryRequirements2KHR: {
            return "OP_vkGetBufferMemoryRequirements2KHR";
        }
        case OP_vkGetImageSparseMemoryRequirements2KHR: {
            return "OP_vkGetImageSparseMemoryRequirements2KHR";
        }
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
        case OP_vkCreateSamplerYcbcrConversionKHR: {
            return "OP_vkCreateSamplerYcbcrConversionKHR";
        }
        case OP_vkDestroySamplerYcbcrConversionKHR: {
            return "OP_vkDestroySamplerYcbcrConversionKHR";
        }
#endif
#ifdef VK_KHR_bind_memory2
        case OP_vkBindBufferMemory2KHR: {
            return "OP_vkBindBufferMemory2KHR";
        }
        case OP_vkBindImageMemory2KHR: {
            return "OP_vkBindImageMemory2KHR";
        }
#endif
#ifdef VK_KHR_maintenance3
        case OP_vkGetDescriptorSetLayoutSupportKHR: {
            return "OP_vkGetDescriptorSetLayoutSupportKHR";
        }
#endif
#ifdef VK_KHR_draw_indirect_count
        case OP_vkCmdDrawIndirectCountKHR: {
            return "OP_vkCmdDrawIndirectCountKHR";
        }
        case OP_vkCmdDrawIndexedIndirectCountKHR: {
            return "OP_vkCmdDrawIndexedIndirectCountKHR";
        }
#endif
#ifdef VK_ANDROID_native_buffer
        case OP_vkGetSwapchainGrallocUsageANDROID: {
            return "OP_vkGetSwapchainGrallocUsageANDROID";
        }
        case OP_vkAcquireImageANDROID: {
            return "OP_vkAcquireImageANDROID";
        }
        case OP_vkQueueSignalReleaseImageANDROID: {
            return "OP_vkQueueSignalReleaseImageANDROID";
        }
#endif
#ifdef VK_EXT_debug_report
        case OP_vkCreateDebugReportCallbackEXT: {
            return "OP_vkCreateDebugReportCallbackEXT";
        }
        case OP_vkDestroyDebugReportCallbackEXT: {
            return "OP_vkDestroyDebugReportCallbackEXT";
        }
        case OP_vkDebugReportMessageEXT: {
            return "OP_vkDebugReportMessageEXT";
        }
#endif
#ifdef VK_EXT_debug_marker
        case OP_vkDebugMarkerSetObjectTagEXT: {
            return "OP_vkDebugMarkerSetObjectTagEXT";
        }
        case OP_vkDebugMarkerSetObjectNameEXT: {
            return "OP_vkDebugMarkerSetObjectNameEXT";
        }
        case OP_vkCmdDebugMarkerBeginEXT: {
            return "OP_vkCmdDebugMarkerBeginEXT";
        }
        case OP_vkCmdDebugMarkerEndEXT: {
            return "OP_vkCmdDebugMarkerEndEXT";
        }
        case OP_vkCmdDebugMarkerInsertEXT: {
            return "OP_vkCmdDebugMarkerInsertEXT";
        }
#endif
#ifdef VK_AMD_draw_indirect_count
        case OP_vkCmdDrawIndirectCountAMD: {
            return "OP_vkCmdDrawIndirectCountAMD";
        }
        case OP_vkCmdDrawIndexedIndirectCountAMD: {
            return "OP_vkCmdDrawIndexedIndirectCountAMD";
        }
#endif
#ifdef VK_AMD_shader_info
        case OP_vkGetShaderInfoAMD: {
            return "OP_vkGetShaderInfoAMD";
        }
#endif
#ifdef VK_NV_external_memory_capabilities
        case OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV: {
            return "OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV";
        }
#endif
#ifdef VK_NV_external_memory_win32
        case OP_vkGetMemoryWin32HandleNV: {
            return "OP_vkGetMemoryWin32HandleNV";
        }
#endif
#ifdef VK_NN_vi_surface
        case OP_vkCreateViSurfaceNN: {
            return "OP_vkCreateViSurfaceNN";
        }
#endif
#ifdef VK_EXT_conditional_rendering
        case OP_vkCmdBeginConditionalRenderingEXT: {
            return "OP_vkCmdBeginConditionalRenderingEXT";
        }
        case OP_vkCmdEndConditionalRenderingEXT: {
            return "OP_vkCmdEndConditionalRenderingEXT";
        }
#endif
#ifdef VK_NV_clip_space_w_scaling
        case OP_vkCmdSetViewportWScalingNV: {
            return "OP_vkCmdSetViewportWScalingNV";
        }
#endif
#ifdef VK_EXT_direct_mode_display
        case OP_vkReleaseDisplayEXT: {
            return "OP_vkReleaseDisplayEXT";
        }
#endif
#ifdef VK_EXT_acquire_xlib_display
        case OP_vkAcquireXlibDisplayEXT: {
            return "OP_vkAcquireXlibDisplayEXT";
        }
        case OP_vkGetRandROutputDisplayEXT: {
            return "OP_vkGetRandROutputDisplayEXT";
        }
#endif
#ifdef VK_EXT_display_surface_counter
        case OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT: {
            return "OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT";
        }
#endif
#ifdef VK_EXT_display_control
        case OP_vkDisplayPowerControlEXT: {
            return "OP_vkDisplayPowerControlEXT";
        }
        case OP_vkRegisterDeviceEventEXT: {
            return "OP_vkRegisterDeviceEventEXT";
        }
        case OP_vkRegisterDisplayEventEXT: {
            return "OP_vkRegisterDisplayEventEXT";
        }
        case OP_vkGetSwapchainCounterEXT: {
            return "OP_vkGetSwapchainCounterEXT";
        }
#endif
#ifdef VK_GOOGLE_display_timing
        case OP_vkGetRefreshCycleDurationGOOGLE: {
            return "OP_vkGetRefreshCycleDurationGOOGLE";
        }
        case OP_vkGetPastPresentationTimingGOOGLE: {
            return "OP_vkGetPastPresentationTimingGOOGLE";
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case OP_vkCmdSetDiscardRectangleEXT: {
            return "OP_vkCmdSetDiscardRectangleEXT";
        }
#endif
#ifdef VK_EXT_hdr_metadata
        case OP_vkSetHdrMetadataEXT: {
            return "OP_vkSetHdrMetadataEXT";
        }
#endif
#ifdef VK_MVK_ios_surface
        case OP_vkCreateIOSSurfaceMVK: {
            return "OP_vkCreateIOSSurfaceMVK";
        }
#endif
#ifdef VK_MVK_macos_surface
        case OP_vkCreateMacOSSurfaceMVK: {
            return "OP_vkCreateMacOSSurfaceMVK";
        }
#endif
#ifdef VK_EXT_debug_utils
        case OP_vkSetDebugUtilsObjectNameEXT: {
            return "OP_vkSetDebugUtilsObjectNameEXT";
        }
        case OP_vkSetDebugUtilsObjectTagEXT: {
            return "OP_vkSetDebugUtilsObjectTagEXT";
        }
        case OP_vkQueueBeginDebugUtilsLabelEXT: {
            return "OP_vkQueueBeginDebugUtilsLabelEXT";
        }
        case OP_vkQueueEndDebugUtilsLabelEXT: {
            return "OP_vkQueueEndDebugUtilsLabelEXT";
        }
        case OP_vkQueueInsertDebugUtilsLabelEXT: {
            return "OP_vkQueueInsertDebugUtilsLabelEXT";
        }
        case OP_vkCmdBeginDebugUtilsLabelEXT: {
            return "OP_vkCmdBeginDebugUtilsLabelEXT";
        }
        case OP_vkCmdEndDebugUtilsLabelEXT: {
            return "OP_vkCmdEndDebugUtilsLabelEXT";
        }
        case OP_vkCmdInsertDebugUtilsLabelEXT: {
            return "OP_vkCmdInsertDebugUtilsLabelEXT";
        }
        case OP_vkCreateDebugUtilsMessengerEXT: {
            return "OP_vkCreateDebugUtilsMessengerEXT";
        }
        case OP_vkDestroyDebugUtilsMessengerEXT: {
            return "OP_vkDestroyDebugUtilsMessengerEXT";
        }
        case OP_vkSubmitDebugUtilsMessageEXT: {
            return "OP_vkSubmitDebugUtilsMessageEXT";
        }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
        case OP_vkGetAndroidHardwareBufferPropertiesANDROID: {
            return "OP_vkGetAndroidHardwareBufferPropertiesANDROID";
        }
        case OP_vkGetMemoryAndroidHardwareBufferANDROID: {
            return "OP_vkGetMemoryAndroidHardwareBufferANDROID";
        }
#endif
#ifdef VK_EXT_sample_locations
        case OP_vkCmdSetSampleLocationsEXT: {
            return "OP_vkCmdSetSampleLocationsEXT";
        }
        case OP_vkGetPhysicalDeviceMultisamplePropertiesEXT: {
            return "OP_vkGetPhysicalDeviceMultisamplePropertiesEXT";
        }
#endif
#ifdef VK_EXT_validation_cache
        case OP_vkCreateValidationCacheEXT: {
            return "OP_vkCreateValidationCacheEXT";
        }
        case OP_vkDestroyValidationCacheEXT: {
            return "OP_vkDestroyValidationCacheEXT";
        }
        case OP_vkMergeValidationCachesEXT: {
            return "OP_vkMergeValidationCachesEXT";
        }
        case OP_vkGetValidationCacheDataEXT: {
            return "OP_vkGetValidationCacheDataEXT";
        }
#endif
#ifdef VK_EXT_external_memory_host
        case OP_vkGetMemoryHostPointerPropertiesEXT: {
            return "OP_vkGetMemoryHostPointerPropertiesEXT";
        }
#endif
#ifdef VK_AMD_buffer_marker
        case OP_vkCmdWriteBufferMarkerAMD: {
            return "OP_vkCmdWriteBufferMarkerAMD";
        }
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
        case OP_vkCmdSetCheckpointNV: {
            return "OP_vkCmdSetCheckpointNV";
        }
        case OP_vkGetQueueCheckpointDataNV: {
            return "OP_vkGetQueueCheckpointDataNV";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
            return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
        }
        case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE: {
            return "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE";
        }
        case OP_vkBeginCommandBufferAsyncGOOGLE: {
            return "OP_vkBeginCommandBufferAsyncGOOGLE";
        }
        case OP_vkEndCommandBufferAsyncGOOGLE: {
            return "OP_vkEndCommandBufferAsyncGOOGLE";
        }
        case OP_vkResetCommandBufferAsyncGOOGLE: {
            return "OP_vkResetCommandBufferAsyncGOOGLE";
        }
        case OP_vkCommandBufferHostSyncGOOGLE: {
            return "OP_vkCommandBufferHostSyncGOOGLE";
        }
        case OP_vkCreateImageWithRequirementsGOOGLE: {
            return "OP_vkCreateImageWithRequirementsGOOGLE";
        }
        case OP_vkCreateBufferWithRequirementsGOOGLE: {
            return "OP_vkCreateBufferWithRequirementsGOOGLE";
        }
        case OP_vkGetMemoryHostAddressInfoGOOGLE: {
            return "OP_vkGetMemoryHostAddressInfoGOOGLE";
        }
        case OP_vkFreeMemorySyncGOOGLE: {
            return "OP_vkFreeMemorySyncGOOGLE";
        }
        case OP_vkQueueHostSyncGOOGLE: {
            return "OP_vkQueueHostSyncGOOGLE";
        }
        case OP_vkQueueSubmitAsyncGOOGLE: {
            return "OP_vkQueueSubmitAsyncGOOGLE";
        }
        case OP_vkQueueWaitIdleAsyncGOOGLE: {
            return "OP_vkQueueWaitIdleAsyncGOOGLE";
        }
        case OP_vkQueueBindSparseAsyncGOOGLE: {
            return "OP_vkQueueBindSparseAsyncGOOGLE";
        }
        case OP_vkGetLinearImageLayoutGOOGLE: {
            return "OP_vkGetLinearImageLayoutGOOGLE";
        }
        case OP_vkQueueFlushCommandsGOOGLE: {
            return "OP_vkQueueFlushCommandsGOOGLE";
        }
        case OP_vkGetBlobGOOGLE: {
            return "OP_vkGetBlobGOOGLE";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetRasterizationSamplesEXT: {
            return "OP_vkCmdSetRasterizationSamplesEXT";
        }
#endif
#ifdef VK_KHR_dynamic_rendering
        case OP_vkCmdEndRenderingKHR: {
            return "OP_vkCmdEndRenderingKHR";
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case OP_vkAcquireFullScreenExclusiveModeEXT: {
            return "OP_vkAcquireFullScreenExclusiveModeEXT";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdPipelineBarrier2KHR: {
            return "OP_vkCmdPipelineBarrier2KHR";
        }
#endif
#ifdef VK_KHR_maintenance4
        case OP_vkGetDeviceBufferMemoryRequirementsKHR: {
            return "OP_vkGetDeviceBufferMemoryRequirementsKHR";
        }
#endif
#ifdef VK_EXT_color_write_enable
        case OP_vkCmdSetColorWriteEnableEXT: {
            return "OP_vkCmdSetColorWriteEnableEXT";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetDescriptorEXT: {
            return "OP_vkGetDescriptorEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetColorBlendAdvancedEXT: {
            return "OP_vkCmdSetColorBlendAdvancedEXT";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkBindAccelerationStructureMemoryNV: {
            return "OP_vkBindAccelerationStructureMemoryNV";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkInitializePerformanceApiINTEL: {
            return "OP_vkInitializePerformanceApiINTEL";
        }
#endif
#ifdef VK_KHR_deferred_host_operations
        case OP_vkGetDeferredOperationMaxConcurrencyKHR: {
            return "OP_vkGetDeferredOperationMaxConcurrencyKHR";
        }
#endif
#ifdef VK_NV_optical_flow
        case OP_vkCreateOpticalFlowSessionNV: {
            return "OP_vkCreateOpticalFlowSessionNV";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
            return "OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT";
        }
#endif
#ifdef VK_EXT_calibrated_timestamps
        case OP_vkGetCalibratedTimestampsEXT: {
            return "OP_vkGetCalibratedTimestampsEXT";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCreateRayTracingPipelinesNV: {
            return "OP_vkCreateRayTracingPipelinesNV";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdCopyMemoryToAccelerationStructureKHR: {
            return "OP_vkCmdCopyMemoryToAccelerationStructureKHR";
        }
#endif
#ifdef VK_KHR_fragment_shading_rate
        case OP_vkCmdSetFragmentShadingRateKHR: {
            return "OP_vkCmdSetFragmentShadingRateKHR";
        }
#endif
#ifdef VK_NVX_image_view_handle
        case OP_vkGetImageViewHandleNVX: {
            return "OP_vkGetImageViewHandleNVX";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetScissorWithCountEXT: {
            return "OP_vkCmdSetScissorWithCountEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetViewportWScalingEnableNV: {
            return "OP_vkCmdSetViewportWScalingEnableNV";
        }
        case OP_vkCmdSetRasterizationStreamEXT: {
            return "OP_vkCmdSetRasterizationStreamEXT";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
            return "OP_vkGetRayTracingShaderGroupStackSizeKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetSampleMaskEXT: {
            return "OP_vkCmdSetSampleMaskEXT";
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case OP_vkGetDeviceGroupSurfacePresentModes2EXT: {
            return "OP_vkGetDeviceGroupSurfacePresentModes2EXT";
        }
#endif
#ifdef VK_NV_mesh_shader
        case OP_vkCmdDrawMeshTasksNV: {
            return "OP_vkCmdDrawMeshTasksNV";
        }
#endif
#ifdef VK_NVX_binary_import
        case OP_vkCreateCuFunctionNVX: {
            return "OP_vkCreateCuFunctionNVX";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCmdWriteAccelerationStructuresPropertiesNV: {
            return "OP_vkCmdWriteAccelerationStructuresPropertiesNV";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCmdBuildMicromapsEXT: {
            return "OP_vkCmdBuildMicromapsEXT";
        }
        case OP_vkWriteMicromapsPropertiesEXT: {
            return "OP_vkWriteMicromapsPropertiesEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case OP_vkCmdSetPatchControlPointsEXT: {
            return "OP_vkCmdSetPatchControlPointsEXT";
        }
#endif
#ifdef VK_EXT_private_data
        case OP_vkDestroyPrivateDataSlotEXT: {
            return "OP_vkDestroyPrivateDataSlotEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetDepthTestEnable: {
            return "OP_vkCmdSetDepthTestEnable";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCmdTraceRaysNV: {
            return "OP_vkCmdTraceRaysNV";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCmdWriteMicromapsPropertiesEXT: {
            return "OP_vkCmdWriteMicromapsPropertiesEXT";
        }
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
        case OP_vkCmdDrawClusterIndirectHUAWEI: {
            return "OP_vkCmdDrawClusterIndirectHUAWEI";
        }
#endif
#ifdef VK_NVX_image_view_handle
        case OP_vkGetImageViewAddressNVX: {
            return "OP_vkGetImageViewAddressNVX";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCmdCopyAccelerationStructureNV: {
            return "OP_vkCmdCopyAccelerationStructureNV";
        }
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
        case OP_vkCmdSetVertexInputEXT: {
            return "OP_vkCmdSetVertexInputEXT";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkCmdTraceRaysIndirectKHR: {
            return "OP_vkCmdTraceRaysIndirectKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetFrontFaceEXT: {
            return "OP_vkCmdSetFrontFaceEXT";
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case OP_vkSetBufferCollectionBufferConstraintsFUCHSIA: {
            return "OP_vkSetBufferCollectionBufferConstraintsFUCHSIA";
        }
#endif
#ifdef VK_FUCHSIA_external_memory
        case OP_vkGetMemoryZirconHandlePropertiesFUCHSIA: {
            return "OP_vkGetMemoryZirconHandlePropertiesFUCHSIA";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkGetPerformanceParameterINTEL: {
            return "OP_vkGetPerformanceParameterINTEL";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkCollectDescriptorPoolIdsGOOGLE: {
            return "OP_vkCollectDescriptorPoolIdsGOOGLE";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkCmdTraceRaysKHR: {
            return "OP_vkCmdTraceRaysKHR";
        }
#endif
#ifdef VK_EXT_shader_module_identifier
        case OP_vkGetShaderModuleCreateInfoIdentifierEXT: {
            return "OP_vkGetShaderModuleCreateInfoIdentifierEXT";
        }
#endif
#ifdef VK_FUCHSIA_external_memory
        case OP_vkGetMemoryZirconHandleFUCHSIA: {
            return "OP_vkGetMemoryZirconHandleFUCHSIA";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdCopyImageToBuffer2: {
            return "OP_vkCmdCopyImageToBuffer2";
        }
#endif
#ifdef VK_NV_shading_rate_image
        case OP_vkCmdSetViewportShadingRatePaletteNV: {
            return "OP_vkCmdSetViewportShadingRatePaletteNV";
        }
#endif
#ifdef VK_KHR_deferred_host_operations
        case OP_vkDestroyDeferredOperationKHR: {
            return "OP_vkDestroyDeferredOperationKHR";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkBindVideoSessionMemoryKHR: {
            return "OP_vkBindVideoSessionMemoryKHR";
        }
#endif
#ifdef VK_NV_optical_flow
        case OP_vkBindOpticalFlowSessionImageNV: {
            return "OP_vkBindOpticalFlowSessionImageNV";
        }
        case OP_vkCmdOpticalFlowExecuteNV: {
            return "OP_vkCmdOpticalFlowExecuteNV";
        }
#endif
#ifdef VK_KHR_deferred_host_operations
        case OP_vkDeferredOperationJoinKHR: {
            return "OP_vkDeferredOperationJoinKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetDepthWriteEnableEXT: {
            return "OP_vkCmdSetDepthWriteEnableEXT";
        }
#endif
#ifdef VK_KHR_buffer_device_address
        case OP_vkGetBufferDeviceAddressKHR: {
            return "OP_vkGetBufferDeviceAddressKHR";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetDepthBoundsTestEnable: {
            return "OP_vkCmdSetDepthBoundsTestEnable";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkGetAccelerationStructureBuildSizesKHR: {
            return "OP_vkGetAccelerationStructureBuildSizesKHR";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetScissorWithCount: {
            return "OP_vkCmdSetScissorWithCount";
        }
#endif
#ifdef VK_NVX_binary_import
        case OP_vkCmdCuLaunchKernelNVX: {
            return "OP_vkCmdCuLaunchKernelNVX";
        }
#endif
#ifdef VK_NV_memory_decompression
        case OP_vkCmdDecompressMemoryNV: {
            return "OP_vkCmdDecompressMemoryNV";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkGetAccelerationStructureMemoryRequirementsNV: {
            return "OP_vkGetAccelerationStructureMemoryRequirementsNV";
        }
#endif
#ifdef VK_HUAWEI_subpass_shading
        case OP_vkCmdSubpassShadingHUAWEI: {
            return "OP_vkCmdSubpassShadingHUAWEI";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdEndRendering: {
            return "OP_vkCmdEndRendering";
        }
#endif
#ifdef VK_EXT_directfb_surface
        case OP_vkCreateDirectFBSurfaceEXT: {
            return "OP_vkCreateDirectFBSurfaceEXT";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCmdEndRenderPass2: {
            return "OP_vkCmdEndRenderPass2";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetDescriptorSetLayoutBindingOffsetEXT: {
            return "OP_vkGetDescriptorSetLayoutBindingOffsetEXT";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
            return "OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkGetBufferDeviceAddress: {
            return "OP_vkGetBufferDeviceAddress";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetFrontFace: {
            return "OP_vkCmdSetFrontFace";
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case OP_vkCmdSetDiscardRectangleModeEXT: {
            return "OP_vkCmdSetDiscardRectangleModeEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetDepthBoundsTestEnableEXT: {
            return "OP_vkCmdSetDepthBoundsTestEnableEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkGetAccelerationStructureDeviceAddressKHR: {
            return "OP_vkGetAccelerationStructureDeviceAddressKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetColorBlendEquationEXT: {
            return "OP_vkCmdSetColorBlendEquationEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdCopyAccelerationStructureToMemoryKHR: {
            return "OP_vkCmdCopyAccelerationStructureToMemoryKHR";
        }
#endif
#ifdef VK_EXT_mesh_shader
        case OP_vkCmdDrawMeshTasksIndirectEXT: {
            return "OP_vkCmdDrawMeshTasksIndirectEXT";
        }
#endif
#ifdef VK_NV_mesh_shader
        case OP_vkCmdDrawMeshTasksIndirectCountNV: {
            return "OP_vkCmdDrawMeshTasksIndirectCountNV";
        }
#endif
#ifdef VK_KHR_performance_query
        case OP_vkReleaseProfilingLockKHR: {
            return "OP_vkReleaseProfilingLockKHR";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkDestroyAccelerationStructureKHR: {
            return "OP_vkDestroyAccelerationStructureKHR";
        }
#endif
#ifdef VK_EXT_pageable_device_local_memory
        case OP_vkSetDeviceMemoryPriorityEXT: {
            return "OP_vkSetDeviceMemoryPriorityEXT";
        }
#endif
#ifdef VK_EXT_buffer_device_address
        case OP_vkGetBufferDeviceAddressEXT: {
            return "OP_vkGetBufferDeviceAddressEXT";
        }
#endif
#ifdef VK_QNX_screen_surface
        case OP_vkCreateScreenSurfaceQNX: {
            return "OP_vkCreateScreenSurfaceQNX";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkDestroyPrivateDataSlot: {
            return "OP_vkDestroyPrivateDataSlot";
        }
        case OP_vkCmdSetCullMode: {
            return "OP_vkCmdSetCullMode";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdWriteBufferMarker2AMD: {
            return "OP_vkCmdWriteBufferMarker2AMD";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkWaitSemaphores: {
            return "OP_vkWaitSemaphores";
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case OP_vkDestroyBufferCollectionFUCHSIA: {
            return "OP_vkDestroyBufferCollectionFUCHSIA";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageModulationModeNV: {
            return "OP_vkCmdSetCoverageModulationModeNV";
        }
#endif
#ifdef VK_EXT_private_data
        case OP_vkSetPrivateDataEXT: {
            return "OP_vkSetPrivateDataEXT";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT: {
            return "OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT";
        }
#endif
#ifdef VK_HUAWEI_subpass_shading
        case OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: {
            return "OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI";
        }
#endif
#ifdef VK_NV_scissor_exclusive
        case OP_vkCmdSetExclusiveScissorNV: {
            return "OP_vkCmdSetExclusiveScissorNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetLineStippleEnableEXT: {
            return "OP_vkCmdSetLineStippleEnableEXT";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdCopyImage2KHR: {
            return "OP_vkCmdCopyImage2KHR";
        }
#endif
#ifdef VK_NVX_binary_import
        case OP_vkCreateCuModuleNVX: {
            return "OP_vkCreateCuModuleNVX";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkCreateVideoSessionKHR: {
            return "OP_vkCreateVideoSessionKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetColorWriteMaskEXT: {
            return "OP_vkCmdSetColorWriteMaskEXT";
        }
#endif
#ifdef VK_KHR_timeline_semaphore
        case OP_vkGetSemaphoreCounterValueKHR: {
            return "OP_vkGetSemaphoreCounterValueKHR";
        }
#endif
#ifdef VK_KHR_map_memory2
        case OP_vkUnmapMemory2KHR: {
            return "OP_vkUnmapMemory2KHR";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkGetRayTracingShaderGroupHandlesNV: {
            return "OP_vkGetRayTracingShaderGroupHandlesNV";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkGetBufferOpaqueCaptureAddress: {
            return "OP_vkGetBufferOpaqueCaptureAddress";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetPrimitiveRestartEnable: {
            return "OP_vkCmdSetPrimitiveRestartEnable";
        }
#endif
#ifdef VK_EXT_swapchain_maintenance1
        case OP_vkReleaseSwapchainImagesEXT: {
            return "OP_vkReleaseSwapchainImagesEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetEvent2: {
            return "OP_vkCmdSetEvent2";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetDescriptorSetLayoutSizeEXT: {
            return "OP_vkGetDescriptorSetLayoutSizeEXT";
        }
#endif
#ifdef VK_KHR_map_memory2
        case OP_vkMapMemory2KHR: {
            return "OP_vkMapMemory2KHR";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkGetDeviceImageSparseMemoryRequirements: {
            return "OP_vkGetDeviceImageSparseMemoryRequirements";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetDepthTestEnableEXT: {
            return "OP_vkCmdSetDepthTestEnableEXT";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCmdCopyMicromapToMemoryEXT: {
            return "OP_vkCmdCopyMicromapToMemoryEXT";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkCmdExecuteGeneratedCommandsNV: {
            return "OP_vkCmdExecuteGeneratedCommandsNV";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCmdBeginRenderPass2: {
            return "OP_vkCmdBeginRenderPass2";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetStencilOp: {
            return "OP_vkCmdSetStencilOp";
        }
#endif
#ifdef VK_EXT_private_data
        case OP_vkCreatePrivateDataSlotEXT: {
            return "OP_vkCreatePrivateDataSlotEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdCopyBuffer2: {
            return "OP_vkCmdCopyBuffer2";
        }
#endif
#ifdef VK_NV_shading_rate_image
        case OP_vkCmdSetCoarseSampleOrderNV: {
            return "OP_vkCmdSetCoarseSampleOrderNV";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkGetPrivateData: {
            return "OP_vkGetPrivateData";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkDestroyVideoSessionParametersKHR: {
            return "OP_vkDestroyVideoSessionParametersKHR";
        }
#endif
#ifdef VK_NV_shading_rate_image
        case OP_vkCmdBindShadingRateImageNV: {
            return "OP_vkCmdBindShadingRateImageNV";
        }
#endif
#ifdef VK_KHR_performance_query
        case OP_vkAcquireProfilingLockKHR: {
            return "OP_vkAcquireProfilingLockKHR";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkDestroyVideoSessionKHR: {
            return "OP_vkDestroyVideoSessionKHR";
        }
        case OP_vkCmdBeginVideoCodingKHR: {
            return "OP_vkCmdBeginVideoCodingKHR";
        }
#endif
#ifdef VK_QCOM_tile_properties
        case OP_vkGetDynamicRenderingTilePropertiesQCOM: {
            return "OP_vkGetDynamicRenderingTilePropertiesQCOM";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetDepthWriteEnable: {
            return "OP_vkCmdSetDepthWriteEnable";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCopyAccelerationStructureKHR: {
            return "OP_vkCopyAccelerationStructureKHR";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkBuildMicromapsEXT: {
            return "OP_vkBuildMicromapsEXT";
        }
#endif
#ifdef VK_GGP_stream_descriptor_surface
        case OP_vkCreateStreamDescriptorSurfaceGGP: {
            return "OP_vkCreateStreamDescriptorSurfaceGGP";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkBuildAccelerationStructuresKHR: {
            return "OP_vkBuildAccelerationStructuresKHR";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkSetPrivateData: {
            return "OP_vkSetPrivateData";
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case OP_vkGetBufferCollectionPropertiesFUCHSIA: {
            return "OP_vkGetBufferCollectionPropertiesFUCHSIA";
        }
#endif
#ifdef VK_EXT_shader_object
        case OP_vkDestroyShaderEXT: {
            return "OP_vkDestroyShaderEXT";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkDestroyMicromapEXT: {
            return "OP_vkDestroyMicromapEXT";
        }
#endif
#ifdef VK_EXT_host_query_reset
        case OP_vkResetQueryPoolEXT: {
            return "OP_vkResetQueryPoolEXT";
        }
#endif
#ifdef VK_KHR_maintenance4
        case OP_vkGetDeviceImageMemoryRequirementsKHR: {
            return "OP_vkGetDeviceImageMemoryRequirementsKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdBindVertexBuffers2EXT: {
            return "OP_vkCmdBindVertexBuffers2EXT";
        }
#endif
#ifdef VK_EXT_pipeline_properties
        case OP_vkGetPipelinePropertiesEXT: {
            return "OP_vkGetPipelinePropertiesEXT";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE: {
            return "OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetImageOpaqueCaptureDescriptorDataEXT: {
            return "OP_vkGetImageOpaqueCaptureDescriptorDataEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetPolygonModeEXT: {
            return "OP_vkCmdSetPolygonModeEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdWaitEvents2: {
            return "OP_vkCmdWaitEvents2";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE: {
            return "OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
            return "OP_vkCmdSetRepresentativeFragmentTestEnableNV";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCmdNextSubpass2: {
            return "OP_vkCmdNextSubpass2";
        }
#endif
#ifdef VK_NV_copy_memory_indirect
        case OP_vkCmdCopyMemoryIndirectNV: {
            return "OP_vkCmdCopyMemoryIndirectNV";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdWaitEvents2KHR: {
            return "OP_vkCmdWaitEvents2KHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageToColorLocationNV: {
            return "OP_vkCmdSetCoverageToColorLocationNV";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCmdDrawIndexedIndirectCount: {
            return "OP_vkCmdDrawIndexedIndirectCount";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case OP_vkCmdSetRasterizerDiscardEnableEXT: {
            return "OP_vkCmdSetRasterizerDiscardEnableEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetDepthCompareOp: {
            return "OP_vkCmdSetDepthCompareOp";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkAcquirePerformanceConfigurationINTEL: {
            return "OP_vkAcquirePerformanceConfigurationINTEL";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdWriteTimestamp2: {
            return "OP_vkCmdWriteTimestamp2";
        }
        case OP_vkCmdCopyImage2: {
            return "OP_vkCmdCopyImage2";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkCreateRayTracingPipelinesKHR: {
            return "OP_vkCreateRayTracingPipelinesKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetDepthCompareOpEXT: {
            return "OP_vkCmdSetDepthCompareOpEXT";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdCopyBuffer2KHR: {
            return "OP_vkCmdCopyBuffer2KHR";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkGetPhysicalDeviceVideoCapabilitiesKHR: {
            return "OP_vkGetPhysicalDeviceVideoCapabilitiesKHR";
        }
#endif
#ifdef VK_QCOM_tile_properties
        case OP_vkGetFramebufferTilePropertiesQCOM: {
            return "OP_vkGetFramebufferTilePropertiesQCOM";
        }
#endif
#ifdef VK_FUCHSIA_external_semaphore
        case OP_vkGetSemaphoreZirconHandleFUCHSIA: {
            return "OP_vkGetSemaphoreZirconHandleFUCHSIA";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdCopyBufferToImage2KHR: {
            return "OP_vkCmdCopyBufferToImage2KHR";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkGetGeneratedCommandsMemoryRequirementsNV: {
            return "OP_vkGetGeneratedCommandsMemoryRequirementsNV";
        }
#endif
#ifdef VK_EXT_acquire_drm_display
        case OP_vkAcquireDrmDisplayEXT: {
            return "OP_vkAcquireDrmDisplayEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetAlphaToCoverageEnableEXT: {
            return "OP_vkCmdSetAlphaToCoverageEnableEXT";
        }
        case OP_vkCmdSetDepthClampEnableEXT: {
            return "OP_vkCmdSetDepthClampEnableEXT";
        }
#endif
#ifdef VK_EXT_image_drm_format_modifier
        case OP_vkGetImageDrmFormatModifierPropertiesEXT: {
            return "OP_vkGetImageDrmFormatModifierPropertiesEXT";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkCmdSetPerformanceOverrideINTEL: {
            return "OP_vkCmdSetPerformanceOverrideINTEL";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetProvokingVertexModeEXT: {
            return "OP_vkCmdSetProvokingVertexModeEXT";
        }
#endif
#ifdef VK_EXT_mesh_shader
        case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
            return "OP_vkCmdDrawMeshTasksIndirectCountEXT";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkResetQueryPool: {
            return "OP_vkResetQueryPool";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdCopyImageToBuffer2KHR: {
            return "OP_vkCmdCopyImageToBuffer2KHR";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdWriteTimestamp2KHR: {
            return "OP_vkCmdWriteTimestamp2KHR";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkDestroyAccelerationStructureNV: {
            return "OP_vkDestroyAccelerationStructureNV";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkReleasePerformanceConfigurationINTEL: {
            return "OP_vkReleasePerformanceConfigurationINTEL";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkCmdControlVideoCodingKHR: {
            return "OP_vkCmdControlVideoCodingKHR";
        }
#endif
#ifdef VK_NVX_binary_import
        case OP_vkDestroyCuFunctionNVX: {
            return "OP_vkDestroyCuFunctionNVX";
        }
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
        case OP_vkCmdDrawClusterHUAWEI: {
            return "OP_vkCmdDrawClusterHUAWEI";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdResolveImage2KHR: {
            return "OP_vkCmdResolveImage2KHR";
        }
#endif
#ifdef VK_EXT_metal_surface
        case OP_vkCreateMetalSurfaceEXT: {
            return "OP_vkCreateMetalSurfaceEXT";
        }
#endif
#ifdef VK_NV_optical_flow
        case OP_vkDestroyOpticalFlowSessionNV: {
            return "OP_vkDestroyOpticalFlowSessionNV";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCopyAccelerationStructureToMemoryKHR: {
            return "OP_vkCopyAccelerationStructureToMemoryKHR";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkGetVideoSessionMemoryRequirementsKHR: {
            return "OP_vkGetVideoSessionMemoryRequirementsKHR";
        }
#endif
#ifdef VK_NV_external_memory_rdma
        case OP_vkGetMemoryRemoteAddressNV: {
            return "OP_vkGetMemoryRemoteAddressNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetViewportWithCountEXT: {
            return "OP_vkCmdSetViewportWithCountEXT";
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case OP_vkReleaseFullScreenExclusiveModeEXT: {
            return "OP_vkReleaseFullScreenExclusiveModeEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdBuildAccelerationStructuresIndirectKHR: {
            return "OP_vkCmdBuildAccelerationStructuresIndirectKHR";
        }
#endif
#ifdef VK_QNX_screen_surface
        case OP_vkGetPhysicalDeviceScreenPresentationSupportQNX: {
            return "OP_vkGetPhysicalDeviceScreenPresentationSupportQNX";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdBindVertexBuffers2: {
            return "OP_vkCmdBindVertexBuffers2";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCreateAccelerationStructureKHR: {
            return "OP_vkCreateAccelerationStructureKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case OP_vkCmdSetDepthBiasEnableEXT: {
            return "OP_vkCmdSetDepthBiasEnableEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageReductionModeNV: {
            return "OP_vkCmdSetCoverageReductionModeNV";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCreateAccelerationStructureNV: {
            return "OP_vkCreateAccelerationStructureNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageModulationTableNV: {
            return "OP_vkCmdSetCoverageModulationTableNV";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCreateMicromapEXT: {
            return "OP_vkCreateMicromapEXT";
        }
#endif
#ifdef VK_KHR_copy_commands2
        case OP_vkCmdBlitImage2KHR: {
            return "OP_vkCmdBlitImage2KHR";
        }
#endif
#ifdef VK_KHR_ray_tracing_pipeline
        case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
            return "OP_vkCmdSetRayTracingPipelineStackSizeKHR";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkGetDeviceMemoryOpaqueCaptureAddress: {
            return "OP_vkGetDeviceMemoryOpaqueCaptureAddress";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetPrimitiveTopologyEXT: {
            return "OP_vkCmdSetPrimitiveTopologyEXT";
        }
#endif
#ifdef VK_KHR_ray_tracing_maintenance1
        case OP_vkCmdTraceRaysIndirect2KHR: {
            return "OP_vkCmdTraceRaysIndirect2KHR";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkUpdateVideoSessionParametersKHR: {
            return "OP_vkUpdateVideoSessionParametersKHR";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkCmdSetPerformanceStreamMarkerINTEL: {
            return "OP_vkCmdSetPerformanceStreamMarkerINTEL";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCopyMemoryToAccelerationStructureKHR: {
            return "OP_vkCopyMemoryToAccelerationStructureKHR";
        }
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
        case OP_vkCreateImagePipeSurfaceFUCHSIA: {
            return "OP_vkCreateImagePipeSurfaceFUCHSIA";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR: {
            return "OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetViewportSwizzleNV: {
            return "OP_vkCmdSetViewportSwizzleNV";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCreatePrivateDataSlot: {
            return "OP_vkCreatePrivateDataSlot";
        }
        case OP_vkCmdSetPrimitiveTopology: {
            return "OP_vkCmdSetPrimitiveTopology";
        }
#endif
#ifdef VK_KHR_present_wait
        case OP_vkWaitForPresentKHR: {
            return "OP_vkWaitForPresentKHR";
        }
#endif
#ifdef VK_EXT_multi_draw
        case OP_vkCmdDrawMultiEXT: {
            return "OP_vkCmdDrawMultiEXT";
        }
#endif
#ifdef VK_KHR_deferred_host_operations
        case OP_vkGetDeferredOperationResultKHR: {
            return "OP_vkGetDeferredOperationResultKHR";
        }
#endif
#ifdef VK_EXT_line_rasterization
        case OP_vkCmdSetLineStippleEXT: {
            return "OP_vkCmdSetLineStippleEXT";
        }
#endif
#ifdef VK_KHR_timeline_semaphore
        case OP_vkWaitSemaphoresKHR: {
            return "OP_vkWaitSemaphoresKHR";
        }
#endif
#ifdef VK_NV_fragment_shading_rate_enums
        case OP_vkCmdSetFragmentShadingRateEnumNV: {
            return "OP_vkCmdSetFragmentShadingRateEnumNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetTessellationDomainOriginEXT: {
            return "OP_vkCmdSetTessellationDomainOriginEXT";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkCreateVideoSessionParametersKHR: {
            return "OP_vkCreateVideoSessionParametersKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetCullModeEXT: {
            return "OP_vkCmdSetCullModeEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkGetDeviceAccelerationStructureCompatibilityKHR: {
            return "OP_vkGetDeviceAccelerationStructureCompatibilityKHR";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkGetSemaphoreCounterValue: {
            return "OP_vkGetSemaphoreCounterValue";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetDepthBiasEnable: {
            return "OP_vkCmdSetDepthBiasEnable";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCopyMicromapToMemoryEXT: {
            return "OP_vkCopyMicromapToMemoryEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetViewportWithCount: {
            return "OP_vkCmdSetViewportWithCount";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case OP_vkCmdSetLogicOpEXT: {
            return "OP_vkCmdSetLogicOpEXT";
        }
#endif
#ifdef VK_AMD_display_native_hdr
        case OP_vkSetLocalDimmingAMD: {
            return "OP_vkSetLocalDimmingAMD";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdBindTransformFeedbackBuffersEXT: {
            return "OP_vkCmdBindTransformFeedbackBuffersEXT";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkQueueCommitDescriptorSetUpdatesGOOGLE: {
            return "OP_vkQueueCommitDescriptorSetUpdatesGOOGLE";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdCopyBufferToImage2: {
            return "OP_vkCmdCopyBufferToImage2";
        }
#endif
#ifdef VK_EXT_full_screen_exclusive
        case OP_vkGetPhysicalDeviceSurfacePresentModes2EXT: {
            return "OP_vkGetPhysicalDeviceSurfacePresentModes2EXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetSampleLocationsEnableEXT: {
            return "OP_vkCmdSetSampleLocationsEnableEXT";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCmdBuildAccelerationStructureNV: {
            return "OP_vkCmdBuildAccelerationStructureNV";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkCmdBindDescriptorBuffersEXT: {
            return "OP_vkCmdBindDescriptorBuffersEXT";
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case OP_vkGetPipelineExecutablePropertiesKHR: {
            return "OP_vkGetPipelineExecutablePropertiesKHR";
        }
#endif
#ifdef VK_EXT_shader_object
        case OP_vkCmdBindShadersEXT: {
            return "OP_vkCmdBindShadersEXT";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkGetAccelerationStructureHandleNV: {
            return "OP_vkGetAccelerationStructureHandleNV";
        }
#endif
#ifdef VK_KHR_timeline_semaphore
        case OP_vkSignalSemaphoreKHR: {
            return "OP_vkSignalSemaphoreKHR";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkCmdSetPerformanceMarkerINTEL: {
            return "OP_vkCmdSetPerformanceMarkerINTEL";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkCmdBindPipelineShaderGroupNV: {
            return "OP_vkCmdBindPipelineShaderGroupNV";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdSetEvent2KHR: {
            return "OP_vkCmdSetEvent2KHR";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCopyMicromapEXT: {
            return "OP_vkCopyMicromapEXT";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkSignalSemaphore: {
            return "OP_vkSignalSemaphore";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
            return "OP_vkCmdSetDescriptorBufferOffsetsEXT";
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case OP_vkGetPipelineExecutableStatisticsKHR: {
            return "OP_vkGetPipelineExecutableStatisticsKHR";
        }
#endif
#ifdef VK_EXT_shader_object
        case OP_vkGetShaderBinaryDataEXT: {
            return "OP_vkGetShaderBinaryDataEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdWriteAccelerationStructuresPropertiesKHR: {
            return "OP_vkCmdWriteAccelerationStructuresPropertiesKHR";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkGetRayTracingShaderGroupHandlesKHR: {
            return "OP_vkGetRayTracingShaderGroupHandlesKHR";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdResetEvent2: {
            return "OP_vkCmdResetEvent2";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdEndTransformFeedbackEXT: {
            return "OP_vkCmdEndTransformFeedbackEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdBuildAccelerationStructuresKHR: {
            return "OP_vkCmdBuildAccelerationStructuresKHR";
        }
#endif
#ifdef VK_KHR_fragment_shading_rate
        case OP_vkGetPhysicalDeviceFragmentShadingRatesKHR: {
            return "OP_vkGetPhysicalDeviceFragmentShadingRatesKHR";
        }
#endif
#ifdef VK_NVX_binary_import
        case OP_vkDestroyCuModuleNVX: {
            return "OP_vkDestroyCuModuleNVX";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT: {
            return "OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT";
        }
#endif
#ifdef VK_NV_mesh_shader
        case OP_vkCmdDrawMeshTasksIndirectNV: {
            return "OP_vkCmdDrawMeshTasksIndirectNV";
        }
#endif
#ifdef VK_KHR_pipeline_executable_properties
        case OP_vkGetPipelineExecutableInternalRepresentationsKHR: {
            return "OP_vkGetPipelineExecutableInternalRepresentationsKHR";
        }
#endif
#ifdef VK_NV_acquire_winrt_display
        case OP_vkAcquireWinrtDisplayNV: {
            return "OP_vkAcquireWinrtDisplayNV";
        }
#endif
#ifdef VK_KHR_deferred_host_operations
        case OP_vkCreateDeferredOperationKHR: {
            return "OP_vkCreateDeferredOperationKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageToColorEnableNV: {
            return "OP_vkCmdSetCoverageToColorEnableNV";
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case OP_vkSetBufferCollectionImageConstraintsFUCHSIA: {
            return "OP_vkSetBufferCollectionImageConstraintsFUCHSIA";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdBlitImage2: {
            return "OP_vkCmdBlitImage2";
        }
        case OP_vkQueueSubmit2: {
            return "OP_vkQueueSubmit2";
        }
#endif
#ifdef VK_KHR_maintenance4
        case OP_vkGetDeviceImageSparseMemoryRequirementsKHR: {
            return "OP_vkGetDeviceImageSparseMemoryRequirementsKHR";
        }
#endif
#ifdef VK_KHR_video_decode_queue
        case OP_vkCmdDecodeVideoKHR: {
            return "OP_vkCmdDecodeVideoKHR";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdBeginQueryIndexedEXT: {
            return "OP_vkCmdBeginQueryIndexedEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetRasterizerDiscardEnable: {
            return "OP_vkCmdSetRasterizerDiscardEnable";
        }
#endif
#ifdef VK_NV_copy_memory_indirect
        case OP_vkCmdCopyMemoryToImageIndirectNV: {
            return "OP_vkCmdCopyMemoryToImageIndirectNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetStencilOpEXT: {
            return "OP_vkCmdSetStencilOpEXT";
        }
#endif
#ifdef VK_FUCHSIA_buffer_collection
        case OP_vkCreateBufferCollectionFUCHSIA: {
            return "OP_vkCreateBufferCollectionFUCHSIA";
        }
#endif
#ifdef VK_EXT_metal_objects
        case OP_vkExportMetalObjectsEXT: {
            return "OP_vkExportMetalObjectsEXT";
        }
#endif
#ifdef VK_NV_ray_tracing
        case OP_vkCompileDeferredNV: {
            return "OP_vkCompileDeferredNV";
        }
#endif
#ifdef VK_EXT_device_fault
        case OP_vkGetDeviceFaultInfoEXT: {
            return "OP_vkGetDeviceFaultInfoEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
            return "OP_vkCmdSetDepthClipNegativeOneToOneEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkCmdCopyAccelerationStructureKHR: {
            return "OP_vkCmdCopyAccelerationStructureKHR";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCreateRenderPass2: {
            return "OP_vkCreateRenderPass2";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdEndQueryIndexedEXT: {
            return "OP_vkCmdEndQueryIndexedEXT";
        }
#endif
#ifdef VK_KHR_video_queue
        case OP_vkCmdEndVideoCodingKHR: {
            return "OP_vkCmdEndVideoCodingKHR";
        }
#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
        case OP_vkGetDescriptorSetHostMappingVALVE: {
            return "OP_vkGetDescriptorSetHostMappingVALVE";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetBufferOpaqueCaptureDescriptorDataEXT: {
            return "OP_vkGetBufferOpaqueCaptureDescriptorDataEXT";
        }
#endif
#ifdef VK_EXT_shader_object
        case OP_vkCreateShadersEXT: {
            return "OP_vkCreateShadersEXT";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCmdCopyMemoryToMicromapEXT: {
            return "OP_vkCmdCopyMemoryToMicromapEXT";
        }
#endif
#ifdef VK_KHR_performance_query
        case OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: {
            return "OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR";
        }
#endif
#ifdef VK_EXT_tooling_info
        case OP_vkGetPhysicalDeviceToolPropertiesEXT: {
            return "OP_vkGetPhysicalDeviceToolPropertiesEXT";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkGetLinearImageLayout2GOOGLE: {
            return "OP_vkGetLinearImageLayout2GOOGLE";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdResolveImage2: {
            return "OP_vkCmdResolveImage2";
        }
        case OP_vkGetDeviceImageMemoryRequirements: {
            return "OP_vkGetDeviceImageMemoryRequirements";
        }
#endif
#ifdef VK_EXT_acquire_drm_display
        case OP_vkGetDrmDisplayEXT: {
            return "OP_vkGetDrmDisplayEXT";
        }
#endif
#ifdef VK_VERSION_1_2
        case OP_vkCmdDrawIndirectCount: {
            return "OP_vkCmdDrawIndirectCount";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetLogicOpEnableEXT: {
            return "OP_vkCmdSetLogicOpEnableEXT";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkGetDeviceMicromapCompatibilityEXT: {
            return "OP_vkGetDeviceMicromapCompatibilityEXT";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkCmdResetEvent2KHR: {
            return "OP_vkCmdResetEvent2KHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetDepthClipEnableEXT: {
            return "OP_vkCmdSetDepthClipEnableEXT";
        }
#endif
#ifdef VK_EXT_discard_rectangles
        case OP_vkCmdSetDiscardRectangleEnableEXT: {
            return "OP_vkCmdSetDiscardRectangleEnableEXT";
        }
#endif
#ifdef VK_NV_memory_decompression
        case OP_vkCmdDecompressMemoryIndirectCountNV: {
            return "OP_vkCmdDecompressMemoryIndirectCountNV";
        }
#endif
#ifdef VK_EXT_multi_draw
        case OP_vkCmdDrawMultiIndexedEXT: {
            return "OP_vkCmdDrawMultiIndexedEXT";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdDrawIndirectByteCountEXT: {
            return "OP_vkCmdDrawIndirectByteCountEXT";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkCreateIndirectCommandsLayoutNV: {
            return "OP_vkCreateIndirectCommandsLayoutNV";
        }
#endif
#ifdef VK_EXT_mesh_shader
        case OP_vkCmdDrawMeshTasksEXT: {
            return "OP_vkCmdDrawMeshTasksEXT";
        }
#endif
#ifdef VK_EXT_directfb_surface
        case OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT: {
            return "OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT";
        }
#endif
#ifdef VK_KHR_buffer_device_address
        case OP_vkGetBufferOpaqueCaptureAddressKHR: {
            return "OP_vkGetBufferOpaqueCaptureAddressKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetCoverageModulationTableEnableNV: {
            return "OP_vkCmdSetCoverageModulationTableEnableNV";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state
        case OP_vkCmdSetStencilTestEnableEXT: {
            return "OP_vkCmdSetStencilTestEnableEXT";
        }
#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
        case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
            return "OP_vkCmdSetAttachmentFeedbackLoopEnableEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdSetStencilTestEnable: {
            return "OP_vkCmdSetStencilTestEnable";
        }
        case OP_vkGetPhysicalDeviceToolProperties: {
            return "OP_vkGetPhysicalDeviceToolProperties";
        }
#endif
#ifdef VK_NV_cooperative_matrix
        case OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: {
            return "OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV";
        }
#endif
#ifdef VK_ANDROID_native_buffer
        case OP_vkGetSwapchainGrallocUsage2ANDROID: {
            return "OP_vkGetSwapchainGrallocUsage2ANDROID";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCmdCopyMicromapEXT: {
            return "OP_vkCmdCopyMicromapEXT";
        }
#endif
#ifdef VK_EXT_shader_module_identifier
        case OP_vkGetShaderModuleIdentifierEXT: {
            return "OP_vkGetShaderModuleIdentifierEXT";
        }
#endif
#ifdef VK_EXT_descriptor_buffer
        case OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT: {
            return "OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT";
        }
#endif
#ifdef VK_KHR_acceleration_structure
        case OP_vkWriteAccelerationStructuresPropertiesKHR: {
            return "OP_vkWriteAccelerationStructuresPropertiesKHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetAlphaToOneEnableEXT: {
            return "OP_vkCmdSetAlphaToOneEnableEXT";
        }
#endif
#ifdef VK_GOOGLE_gfxstream
        case OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE: {
            return "OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkGetMicromapBuildSizesEXT: {
            return "OP_vkGetMicromapBuildSizesEXT";
        }
#endif
#ifdef VK_NV_scissor_exclusive
        case OP_vkCmdSetExclusiveScissorEnableNV: {
            return "OP_vkCmdSetExclusiveScissorEnableNV";
        }
#endif
#ifdef VK_NV_optical_flow
        case OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV: {
            return "OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV";
        }
#endif
#ifdef VK_EXT_private_data
        case OP_vkGetPrivateDataEXT: {
            return "OP_vkGetPrivateDataEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
            return "OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT";
        }
#endif
#ifdef VK_NV_coverage_reduction_mode
        case OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: {
            return "OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkGetQueueCheckpointData2NV: {
            return "OP_vkGetQueueCheckpointData2NV";
        }
#endif
#ifdef VK_EXT_opacity_micromap
        case OP_vkCopyMemoryToMicromapEXT: {
            return "OP_vkCopyMemoryToMicromapEXT";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkDestroyIndirectCommandsLayoutNV: {
            return "OP_vkDestroyIndirectCommandsLayoutNV";
        }
#endif
#ifdef VK_KHR_synchronization2
        case OP_vkQueueSubmit2KHR: {
            return "OP_vkQueueSubmit2KHR";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetConservativeRasterizationModeEXT: {
            return "OP_vkCmdSetConservativeRasterizationModeEXT";
        }
        case OP_vkCmdSetLineRasterizationModeEXT: {
            return "OP_vkCmdSetLineRasterizationModeEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkGetDeviceBufferMemoryRequirements: {
            return "OP_vkGetDeviceBufferMemoryRequirements";
        }
#endif
#ifdef VK_NV_acquire_winrt_display
        case OP_vkGetWinrtDisplayNV: {
            return "OP_vkGetWinrtDisplayNV";
        }
#endif
#ifdef VK_EXT_transform_feedback
        case OP_vkCmdBeginTransformFeedbackEXT: {
            return "OP_vkCmdBeginTransformFeedbackEXT";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdBeginRendering: {
            return "OP_vkCmdBeginRendering";
        }
#endif
#ifdef VK_KHR_buffer_device_address
        case OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR: {
            return "OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkQueueSetPerformanceConfigurationINTEL: {
            return "OP_vkQueueSetPerformanceConfigurationINTEL";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetColorBlendEnableEXT: {
            return "OP_vkCmdSetColorBlendEnableEXT";
        }
#endif
#ifdef VK_EXT_calibrated_timestamps
        case OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: {
            return "OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT";
        }
#endif
#ifdef VK_KHR_video_encode_queue
        case OP_vkCmdEncodeVideoKHR: {
            return "OP_vkCmdEncodeVideoKHR";
        }
#endif
#ifdef VK_INTEL_performance_query
        case OP_vkUninitializePerformanceApiINTEL: {
            return "OP_vkUninitializePerformanceApiINTEL";
        }
#endif
#ifdef VK_EXT_image_compression_control
        case OP_vkGetImageSubresourceLayout2EXT: {
            return "OP_vkGetImageSubresourceLayout2EXT";
        }
#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
        case OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE: {
            return "OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE";
        }
#endif
#ifdef VK_VERSION_1_3
        case OP_vkCmdPipelineBarrier2: {
            return "OP_vkCmdPipelineBarrier2";
        }
#endif
#ifdef VK_NV_device_generated_commands
        case OP_vkCmdPreprocessGeneratedCommandsNV: {
            return "OP_vkCmdPreprocessGeneratedCommandsNV";
        }
#endif
#ifdef VK_KHR_dynamic_rendering
        case OP_vkCmdBeginRenderingKHR: {
            return "OP_vkCmdBeginRenderingKHR";
        }
#endif
#ifdef VK_EXT_headless_surface
        case OP_vkCreateHeadlessSurfaceEXT: {
            return "OP_vkCreateHeadlessSurfaceEXT";
        }
#endif
#ifdef VK_KHR_performance_query
        case OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: {
            return "OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR";
        }
#endif
#ifdef VK_HUAWEI_invocation_mask
        case OP_vkCmdBindInvocationMaskHUAWEI: {
            return "OP_vkCmdBindInvocationMaskHUAWEI";
        }
#endif
#ifdef VK_FUCHSIA_external_semaphore
        case OP_vkImportSemaphoreZirconHandleFUCHSIA: {
            return "OP_vkImportSemaphoreZirconHandleFUCHSIA";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state2
        case OP_vkCmdSetPrimitiveRestartEnableEXT: {
            return "OP_vkCmdSetPrimitiveRestartEnableEXT";
        }
#endif
#ifdef VK_EXT_extended_dynamic_state3
        case OP_vkCmdSetShadingRateImageEnableNV: {
            return "OP_vkCmdSetShadingRateImageEnableNV";
        }
#endif
        default: {
            return "OP_UNKNOWN_API_CALL";
        }
    }
}

}  // namespace vk
}  // namespace gfxstream