system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp

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

// Autogenerated module goldfish_vk_reserved_marshaling_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
// -o ../vulkan-cereal/stream-servers/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_reserved_marshaling_guest.h"

#include <cstring>

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

namespace goldfish_vk {

void reservedmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const void* structExtension, uint8_t** ptr);

void reservedunmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        void* structExtension_out, uint8_t** ptr);

#ifdef VK_VERSION_1_0
void reservedmarshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                const VkExtent2D* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                const VkExtent3D* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                const VkOffset2D* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (int32_t*)&forMarshaling->x, sizeof(int32_t));
    *ptr += sizeof(int32_t);
    memcpy(*ptr, (int32_t*)&forMarshaling->y, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                const VkOffset3D* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (int32_t*)&forMarshaling->x, sizeof(int32_t));
    *ptr += sizeof(int32_t);
    memcpy(*ptr, (int32_t*)&forMarshaling->y, sizeof(int32_t));
    *ptr += sizeof(int32_t);
    memcpy(*ptr, (int32_t*)&forMarshaling->z, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
                              const VkRect2D* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent), ptr);
}

void reservedmarshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkBaseInStructure* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}

void reservedmarshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkBaseOutStructure* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}

void reservedmarshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkBufferMemoryBarrier* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkDispatchIndirectCommand* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->x, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->y, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->z, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkDrawIndexedIndirectCommand* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
    *ptr += sizeof(int32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkDrawIndirectCommand* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkImageSubresourceRange* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->baseMipLevel, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->levelCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkImageMemoryBarrier* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    reservedmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}

void reservedmarshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                     const VkMemoryBarrier* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
}

void reservedmarshal_VkPipelineCacheHeaderVersionOne(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineCacheHeaderVersionOne* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion,
           sizeof(VkPipelineCacheHeaderVersion));
    *ptr += sizeof(VkPipelineCacheHeaderVersion);
    memcpy(*ptr, (uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
}

void reservedmarshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkAllocationCallbacks* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pUserData) {
        memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
        *ptr += sizeof(uint8_t);
    }
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->pfnAllocation;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_2 = (uint64_t)forMarshaling->pfnReallocation;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_3 = (uint64_t)forMarshaling->pfnFree;
    memcpy((*ptr), &cgen_var_3, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_4 = (uint64_t)forMarshaling->pfnInternalAllocation;
    memcpy((*ptr), &cgen_var_4, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_5 = (uint64_t)forMarshaling->pfnInternalFree;
    memcpy((*ptr), &cgen_var_5, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

void reservedmarshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkApplicationInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
        // WARNING PTR CHECK
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationName;
        memcpy((*ptr), &cgen_var_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
        if (forMarshaling->pApplicationName) {
            {
                uint32_t l =
                    forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName) : 0;
                memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
                android::base::Stream::toBe32((uint8_t*)*ptr);
                *ptr += sizeof(uint32_t);
                memcpy(*ptr, (char*)forMarshaling->pApplicationName, l);
                *ptr += l;
            }
        }
    } else {
        {
            uint32_t l =
                forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName) : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            memcpy(*ptr, (char*)forMarshaling->pApplicationName, l);
            *ptr += l;
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
    *ptr += 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;
        memcpy((*ptr), &cgen_var_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
        if (forMarshaling->pEngineName) {
            {
                uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName) : 0;
                memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
                android::base::Stream::toBe32((uint8_t*)*ptr);
                *ptr += sizeof(uint32_t);
                memcpy(*ptr, (char*)forMarshaling->pEngineName, l);
                *ptr += l;
            }
        }
    } else {
        {
            uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName) : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            memcpy(*ptr, (char*)forMarshaling->pEngineName, l);
            *ptr += l;
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkFormatProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures,
           sizeof(VkFormatFeatureFlags));
    *ptr += sizeof(VkFormatFeatureFlags);
    memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures,
           sizeof(VkFormatFeatureFlags));
    *ptr += sizeof(VkFormatFeatureFlags);
    memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->bufferFeatures,
           sizeof(VkFormatFeatureFlags));
    *ptr += sizeof(VkFormatFeatureFlags);
}

void reservedmarshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkImageFormatProperties* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxArrayLayers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    *ptr += sizeof(VkSampleCountFlags);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxResourceSize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkInstanceCreateInfo* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
    *ptr += sizeof(VkInstanceCreateFlags);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pApplicationInfo) {
        reservedmarshal_VkApplicationInfo(
            vkStream, rootType, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    {
        uint32_t c = 0;
        if (forMarshaling) {
            c = forMarshaling->enabledLayerCount;
        }
        memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        for (uint32_t i = 0; i < c; ++i) {
            uint32_t l = forMarshaling->ppEnabledLayerNames
                             ? strlen(forMarshaling->ppEnabledLayerNames[i])
                             : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            if (l) {
                memcpy(*ptr, (char*)(forMarshaling->ppEnabledLayerNames[i]), l);
                *ptr += l;
            }
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    {
        uint32_t c = 0;
        if (forMarshaling) {
            c = forMarshaling->enabledExtensionCount;
        }
        memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        for (uint32_t i = 0; i < c; ++i) {
            uint32_t l = forMarshaling->ppEnabledExtensionNames
                             ? strlen(forMarshaling->ppEnabledExtensionNames[i])
                             : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            if (l) {
                memcpy(*ptr, (char*)(forMarshaling->ppEnabledExtensionNames[i]), l);
                *ptr += l;
            }
        }
    }
}

void reservedmarshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkMemoryHeap* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
    *ptr += sizeof(VkMemoryHeapFlags);
}

void reservedmarshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkMemoryType* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkMemoryPropertyFlags*)&forMarshaling->propertyFlags,
           sizeof(VkMemoryPropertyFlags));
    *ptr += sizeof(VkMemoryPropertyFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

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

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

void reservedmarshal_VkPhysicalDeviceMemoryProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
        reservedmarshal_VkMemoryType(vkStream, rootType,
                                     (VkMemoryType*)(forMarshaling->memoryTypes + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryHeapCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
        reservedmarshal_VkMemoryHeap(vkStream, rootType,
                                     (VkMemoryHeap*)(forMarshaling->memoryHeaps + i), ptr);
    }
}

void reservedmarshal_VkPhysicalDeviceSparseProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSparseProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->residencyAlignedMipSize, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->residencyNonResidentStrict, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkPhysicalDeviceProperties* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkPhysicalDeviceType*)&forMarshaling->deviceType, sizeof(VkPhysicalDeviceType));
    *ptr += sizeof(VkPhysicalDeviceType);
    memcpy(*ptr, (char*)forMarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
    *ptr += VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char);
    memcpy(*ptr, (uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
    reservedmarshal_VkPhysicalDeviceLimits(vkStream, rootType,
                                           (VkPhysicalDeviceLimits*)(&forMarshaling->limits), ptr);
    reservedmarshal_VkPhysicalDeviceSparseProperties(
        vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties),
        ptr);
}

void reservedmarshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkQueueFamilyProperties* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
    *ptr += sizeof(VkQueueFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkExtent3D(vkStream, rootType,
                               (VkExtent3D*)(&forMarshaling->minImageTransferGranularity), ptr);
}

void reservedmarshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkDeviceQueueCreateInfo* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags,
           sizeof(VkDeviceQueueCreateFlags));
    *ptr += sizeof(VkDeviceQueueCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const float*)forMarshaling->pQueuePriorities,
           forMarshaling->queueCount * sizeof(const float));
    *ptr += forMarshaling->queueCount * sizeof(const float);
}

void reservedmarshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkDeviceCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
    *ptr += sizeof(VkDeviceCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i) {
        reservedmarshal_VkDeviceQueueCreateInfo(
            vkStream, rootType,
            (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    {
        uint32_t c = 0;
        if (forMarshaling) {
            c = forMarshaling->enabledLayerCount;
        }
        memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        for (uint32_t i = 0; i < c; ++i) {
            uint32_t l = forMarshaling->ppEnabledLayerNames
                             ? strlen(forMarshaling->ppEnabledLayerNames[i])
                             : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            if (l) {
                memcpy(*ptr, (char*)(forMarshaling->ppEnabledLayerNames[i]), l);
                *ptr += l;
            }
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    {
        uint32_t c = 0;
        if (forMarshaling) {
            c = forMarshaling->enabledExtensionCount;
        }
        memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        for (uint32_t i = 0; i < c; ++i) {
            uint32_t l = forMarshaling->ppEnabledExtensionNames
                             ? strlen(forMarshaling->ppEnabledExtensionNames[i])
                             : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
            android::base::Stream::toBe32((uint8_t*)*ptr);
            *ptr += sizeof(uint32_t);
            if (l) {
                memcpy(*ptr, (char*)(forMarshaling->ppEnabledExtensionNames[i]), l);
                *ptr += l;
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pEnabledFeatures) {
        reservedmarshal_VkPhysicalDeviceFeatures(
            vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures),
            ptr);
    }
}

void reservedmarshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkExtensionProperties* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
    memcpy(*ptr, (uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkLayerProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
    memcpy(*ptr, (uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->implementationVersion, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
}

void reservedmarshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkSubmitInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->waitSemaphoreCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->waitSemaphoreCount;
    }
    memcpy(*ptr, (const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask,
           forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
    *ptr += forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->commandBufferCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->commandBufferCount; ++k) {
                uint64_t tmpval = get_host_u64_VkCommandBuffer(forMarshaling->pCommandBuffers[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->commandBufferCount;
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->signalSemaphoreCount) {
        uint8_t* cgen_var_2_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSignalSemaphores[k]);
                memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->signalSemaphoreCount;
    }
}

void reservedmarshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkMappedMemoryRange* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkMemoryAllocateInfo* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkMemoryRequirements* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkSparseMemoryBind* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
    *ptr += sizeof(VkSparseMemoryBindFlags);
}

void reservedmarshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkSparseBufferMemoryBindInfo* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
        reservedmarshal_VkSparseMemoryBind(
            vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
    }
}

void reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSparseImageOpaqueMemoryBindInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
        reservedmarshal_VkSparseMemoryBind(
            vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
    }
}

void reservedmarshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkImageSubresource* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->arrayLayer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkSparseImageMemoryBind* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkImageSubresource(vkStream, rootType,
                                       (VkImageSubresource*)(&forMarshaling->subresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->offset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
    *ptr += sizeof(VkSparseMemoryBindFlags);
}

void reservedmarshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkSparseImageMemoryBindInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
        reservedmarshal_VkSparseImageMemoryBind(
            vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i), ptr);
    }
}

void reservedmarshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkBindSparseInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->waitSemaphoreCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->waitSemaphoreCount;
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i) {
        reservedmarshal_VkSparseBufferMemoryBindInfo(
            vkStream, rootType,
            (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i) {
        reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
            vkStream, rootType,
            (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i) {
        reservedmarshal_VkSparseImageMemoryBindInfo(
            vkStream, rootType,
            (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->signalSemaphoreCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSignalSemaphores[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->signalSemaphoreCount;
    }
}

void reservedmarshal_VkSparseImageFormatProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSparseImageFormatProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity),
                               ptr);
    memcpy(*ptr, (VkSparseImageFormatFlags*)&forMarshaling->flags,
           sizeof(VkSparseImageFormatFlags));
    *ptr += sizeof(VkSparseImageFormatFlags);
}

void reservedmarshal_VkSparseImageMemoryRequirements(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSparseImageMemoryRequirements* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties),
        ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->imageMipTailStride, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkFenceCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
    *ptr += sizeof(VkFenceCreateFlags);
}

void reservedmarshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkSemaphoreCreateInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
    *ptr += sizeof(VkSemaphoreCreateFlags);
}

void reservedmarshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkEventCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
    *ptr += sizeof(VkEventCreateFlags);
}

void reservedmarshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkQueryPoolCreateInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
    *ptr += sizeof(VkQueryPoolCreateFlags);
    memcpy(*ptr, (VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
    *ptr += sizeof(VkQueryType);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
           sizeof(VkQueryPipelineStatisticFlags));
    *ptr += sizeof(VkQueryPipelineStatisticFlags);
}

void reservedmarshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkBufferCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
    *ptr += sizeof(VkBufferCreateFlags);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
    *ptr += sizeof(VkBufferUsageFlags);
    memcpy(*ptr, (VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
    *ptr += sizeof(VkSharingMode);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pQueueFamilyIndices) {
        memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
               forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        *ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
    }
}

void reservedmarshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkBufferViewCreateInfo* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
    *ptr += sizeof(VkBufferViewCreateFlags);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkImageCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
    *ptr += sizeof(VkImageCreateFlags);
    memcpy(*ptr, (VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
    *ptr += sizeof(VkImageType);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevels, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->arrayLayers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
    *ptr += sizeof(VkImageTiling);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
    *ptr += sizeof(VkSharingMode);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pQueueFamilyIndices) {
        memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
               forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        *ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
    }
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkSubresourceLayout* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->rowPitch, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->arrayPitch, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->depthPitch, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkComponentMapping* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
    *ptr += sizeof(VkComponentSwizzle);
    memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
    *ptr += sizeof(VkComponentSwizzle);
    memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->b, sizeof(VkComponentSwizzle));
    *ptr += sizeof(VkComponentSwizzle);
    memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->a, sizeof(VkComponentSwizzle));
    *ptr += sizeof(VkComponentSwizzle);
}

void reservedmarshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkImageViewCreateInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
    *ptr += sizeof(VkImageViewCreateFlags);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
    *ptr += sizeof(VkImageViewType);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    reservedmarshal_VkComponentMapping(vkStream, rootType,
                                       (VkComponentMapping*)(&forMarshaling->components), ptr);
    reservedmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}

void reservedmarshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkShaderModuleCreateInfo* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkShaderModuleCreateFlags*)&forMarshaling->flags,
           sizeof(VkShaderModuleCreateFlags));
    *ptr += sizeof(VkShaderModuleCreateFlags);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (const uint32_t*)forMarshaling->pCode,
           (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
    *ptr += (forMarshaling->codeSize / 4) * sizeof(const uint32_t);
}

void reservedmarshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkPipelineCacheCreateInfo* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineCacheCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineCacheCreateFlags));
    *ptr += sizeof(VkPipelineCacheCreateFlags);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (const void*)forMarshaling->pInitialData,
           forMarshaling->initialDataSize * sizeof(const uint8_t));
    *ptr += forMarshaling->initialDataSize * sizeof(const uint8_t);
}

void reservedmarshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkSpecializationMapEntry* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->size;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

void reservedmarshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkSpecializationInfo* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i) {
        reservedmarshal_VkSpecializationMapEntry(
            vkStream, rootType, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i),
            ptr);
    }
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (const void*)forMarshaling->pData,
           forMarshaling->dataSize * sizeof(const uint8_t));
    *ptr += forMarshaling->dataSize * sizeof(const uint8_t);
}

void reservedmarshal_VkPipelineShaderStageCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineShaderStageCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineShaderStageCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineShaderStageCreateFlags));
    *ptr += sizeof(VkPipelineShaderStageCreateFlags);
    memcpy(*ptr, (VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
    *ptr += sizeof(VkShaderStageFlagBits);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkShaderModule((*&forMarshaling->module));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    {
        uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->pName, l);
        *ptr += l;
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSpecializationInfo) {
        reservedmarshal_VkSpecializationInfo(
            vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo),
            ptr);
    }
}

void reservedmarshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkComputePipelineCreateInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    *ptr += sizeof(VkPipelineCreateFlags);
    reservedmarshal_VkPipelineShaderStageCreateInfo(
        vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage), ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkPipeline((*&forMarshaling->basePipelineHandle));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkVertexInputBindingDescription(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVertexInputBindingDescription* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
    *ptr += sizeof(VkVertexInputRate);
}

void reservedmarshal_VkVertexInputAttributeDescription(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVertexInputAttributeDescription* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->location, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineVertexInputStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineVertexInputStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineVertexInputStateCreateFlags));
    *ptr += sizeof(VkPipelineVertexInputStateCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i) {
        reservedmarshal_VkVertexInputBindingDescription(
            vkStream, rootType,
            (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i) {
        reservedmarshal_VkVertexInputAttributeDescription(
            vkStream, rootType,
            (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions +
                                                       i),
            ptr);
    }
}

void reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineInputAssemblyStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineInputAssemblyStateCreateFlags));
    *ptr += sizeof(VkPipelineInputAssemblyStateCreateFlags);
    memcpy(*ptr, (VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
    *ptr += sizeof(VkPrimitiveTopology);
    memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineTessellationStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineTessellationStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineTessellationStateCreateFlags));
    *ptr += sizeof(VkPipelineTessellationStateCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                const VkViewport* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->y, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->width, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->height, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->minDepth, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->maxDepth, sizeof(float));
    *ptr += sizeof(float);
}

void reservedmarshal_VkPipelineViewportStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineViewportStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineViewportStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineViewportStateCreateFlags));
    *ptr += sizeof(VkPipelineViewportStateCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pViewports) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
            reservedmarshal_VkViewport(vkStream, rootType,
                                       (const VkViewport*)(forMarshaling->pViewports + i), ptr);
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pScissors) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i) {
            reservedmarshal_VkRect2D(vkStream, rootType,
                                     (const VkRect2D*)(forMarshaling->pScissors + i), ptr);
        }
    }
}

void reservedmarshal_VkPipelineRasterizationStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineRasterizationStateCreateFlags));
    *ptr += sizeof(VkPipelineRasterizationStateCreateFlags);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkPolygonMode*)&forMarshaling->polygonMode, sizeof(VkPolygonMode));
    *ptr += sizeof(VkPolygonMode);
    memcpy(*ptr, (VkCullModeFlags*)&forMarshaling->cullMode, sizeof(VkCullModeFlags));
    *ptr += sizeof(VkCullModeFlags);
    memcpy(*ptr, (VkFrontFace*)&forMarshaling->frontFace, sizeof(VkFrontFace));
    *ptr += sizeof(VkFrontFace);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthBiasEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (float*)&forMarshaling->depthBiasConstantFactor, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->depthBiasClamp, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->depthBiasSlopeFactor, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->lineWidth, sizeof(float));
    *ptr += sizeof(float);
}

void reservedmarshal_VkPipelineMultisampleStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineMultisampleStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineMultisampleStateCreateFlags));
    *ptr += sizeof(VkPipelineMultisampleStateCreateFlags);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
           sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (float*)&forMarshaling->minSampleShading, sizeof(float));
    *ptr += sizeof(float);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSampleMask) {
        memcpy(*ptr, (const VkSampleMask*)forMarshaling->pSampleMask,
               (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
        *ptr += (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask);
    }
    memcpy(*ptr, (VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->alphaToOneEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkStencilOpState* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
    *ptr += sizeof(VkStencilOp);
    memcpy(*ptr, (VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
    *ptr += sizeof(VkStencilOp);
    memcpy(*ptr, (VkStencilOp*)&forMarshaling->depthFailOp, sizeof(VkStencilOp));
    *ptr += sizeof(VkStencilOp);
    memcpy(*ptr, (VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
    *ptr += sizeof(VkCompareOp);
    memcpy(*ptr, (uint32_t*)&forMarshaling->compareMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->writeMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->reference, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineDepthStencilStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineDepthStencilStateCreateFlags));
    *ptr += sizeof(VkPipelineDepthStencilStateCreateFlags);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthWriteEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkCompareOp*)&forMarshaling->depthCompareOp, sizeof(VkCompareOp));
    *ptr += sizeof(VkCompareOp);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthBoundsTestEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->front),
                                     ptr);
    reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->back),
                                     ptr);
    memcpy(*ptr, (float*)&forMarshaling->minDepthBounds, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->maxDepthBounds, sizeof(float));
    *ptr += sizeof(float);
}

void reservedmarshal_VkPipelineColorBlendAttachmentState(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineColorBlendAttachmentState* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
    *ptr += sizeof(VkBlendFactor);
    memcpy(*ptr, (VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
    *ptr += sizeof(VkBlendFactor);
    memcpy(*ptr, (VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
    *ptr += sizeof(VkBlendOp);
    memcpy(*ptr, (VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
    *ptr += sizeof(VkBlendFactor);
    memcpy(*ptr, (VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
    *ptr += sizeof(VkBlendFactor);
    memcpy(*ptr, (VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
    *ptr += sizeof(VkBlendOp);
    memcpy(*ptr, (VkColorComponentFlags*)&forMarshaling->colorWriteMask,
           sizeof(VkColorComponentFlags));
    *ptr += sizeof(VkColorComponentFlags);
}

void reservedmarshal_VkPipelineColorBlendStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineColorBlendStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineColorBlendStateCreateFlags));
    *ptr += sizeof(VkPipelineColorBlendStateCreateFlags);
    memcpy(*ptr, (VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
    *ptr += sizeof(VkLogicOp);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
        reservedmarshal_VkPipelineColorBlendAttachmentState(
            vkStream, rootType,
            (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i), ptr);
    }
    memcpy(*ptr, (float*)forMarshaling->blendConstants, 4 * sizeof(float));
    *ptr += 4 * sizeof(float);
}

void reservedmarshal_VkPipelineDynamicStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineDynamicStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineDynamicStateCreateFlags));
    *ptr += sizeof(VkPipelineDynamicStateCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkDynamicState*)forMarshaling->pDynamicStates,
           forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
    *ptr += forMarshaling->dynamicStateCount * sizeof(const VkDynamicState);
}

void reservedmarshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkGraphicsPipelineCreateInfo* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (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;
        memcpy((*ptr), &cgen_var_0, 4);
        android::base::Stream::toBe32((uint8_t*)(*ptr));
        *ptr += 4;
    }
    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;
        memcpy((*ptr), &cgen_var_0, 4);
        android::base::Stream::toBe32((uint8_t*)(*ptr));
        *ptr += 4;
    }
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
    *ptr += sizeof(VkPipelineCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
        reservedmarshal_VkPipelineShaderStageCreateInfo(
            vkStream, rootType,
            (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
        memcpy((*ptr), &cgen_var_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pVertexInputState)) {
        reservedmarshal_VkPipelineVertexInputStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
        memcpy((*ptr), &cgen_var_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pInputAssemblyState)) {
        reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState),
            ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pTessellationState) {
        if (hasTessellation) {
            reservedmarshal_VkPipelineTessellationStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState),
                ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pViewportState) {
        if (hasRasterization) {
            reservedmarshal_VkPipelineViewportStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState), ptr);
        }
    }
    // WARNING PTR CHECK
    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
        uint64_t cgen_var_1_0 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
        memcpy((*ptr), &cgen_var_1_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
    }
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         forMarshaling->pRasterizationState)) {
        reservedmarshal_VkPipelineRasterizationStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState),
            ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pMultisampleState) {
        if (hasRasterization) {
            reservedmarshal_VkPipelineMultisampleStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState),
                ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
    memcpy((*ptr), &cgen_var_3, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDepthStencilState) {
        if (hasRasterization) {
            reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState),
                ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_4 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
    memcpy((*ptr), &cgen_var_4, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pColorBlendState) {
        if (hasRasterization) {
            reservedmarshal_VkPipelineColorBlendStateCreateInfo(
                vkStream, rootType,
                (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState), ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_5 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
    memcpy((*ptr), &cgen_var_5, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDynamicState) {
        reservedmarshal_VkPipelineDynamicStateCreateInfo(
            vkStream, rootType,
            (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
    }
    uint64_t cgen_var_6;
    *&cgen_var_6 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
    memcpy(*ptr, (uint64_t*)&cgen_var_6, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_7;
    *&cgen_var_7 = get_host_u64_VkRenderPass((*&forMarshaling->renderPass));
    memcpy(*ptr, (uint64_t*)&cgen_var_7, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_8;
    *&cgen_var_8 = get_host_u64_VkPipeline((*&forMarshaling->basePipelineHandle));
    memcpy(*ptr, (uint64_t*)&cgen_var_8, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkPushConstantRange* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
    *ptr += sizeof(VkShaderStageFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->size, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkPipelineLayoutCreateInfo* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineLayoutCreateFlags*)&forMarshaling->flags,
           sizeof(VkPipelineLayoutCreateFlags));
    *ptr += sizeof(VkPipelineLayoutCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->setLayoutCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->setLayoutCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDescriptorSetLayout(forMarshaling->pSetLayouts[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->setLayoutCount;
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
        reservedmarshal_VkPushConstantRange(
            vkStream, rootType,
            (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i), ptr);
    }
}

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

void reservedmarshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkCopyDescriptorSet* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDescriptorSet((*&forMarshaling->srcSet));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkDescriptorSet((*&forMarshaling->dstSet));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkDescriptorBufferInfo* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkDescriptorImageInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSampler((*&forMarshaling->sampler));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImageView((*&forMarshaling->imageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkDescriptorPoolSize* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
    *ptr += sizeof(VkDescriptorType);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkDescriptorPoolCreateInfo* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDescriptorPoolCreateFlags*)&forMarshaling->flags,
           sizeof(VkDescriptorPoolCreateFlags));
    *ptr += sizeof(VkDescriptorPoolCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i) {
        reservedmarshal_VkDescriptorPoolSize(
            vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i), ptr);
    }
}

void reservedmarshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkDescriptorSetAllocateInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDescriptorPool((*&forMarshaling->descriptorPool));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->descriptorSetCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->descriptorSetCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDescriptorSetLayout(forMarshaling->pSetLayouts[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->descriptorSetCount;
    }
}

void reservedmarshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkDescriptorSetLayoutBinding* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    *ptr += sizeof(VkDescriptorType);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
    *ptr += sizeof(VkShaderStageFlags);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pImmutableSamplers) {
        if (forMarshaling->descriptorCount) {
            uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
            if (forMarshaling) {
                for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k) {
                    uint64_t tmpval = get_host_u64_VkSampler(forMarshaling->pImmutableSamplers[k]);
                    memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
                }
            }
            *ptr += 8 * forMarshaling->descriptorCount;
        }
    }
}

void reservedmarshal_VkDescriptorSetLayoutCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorSetLayoutCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags,
           sizeof(VkDescriptorSetLayoutCreateFlags));
    *ptr += sizeof(VkDescriptorSetLayoutCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i) {
        reservedmarshal_VkDescriptorSetLayoutBinding(
            vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i),
            ptr);
    }
}

void reservedmarshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkWriteDescriptorSet* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDescriptorSet((*&forMarshaling->dstSet));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    *ptr += sizeof(VkDescriptorType);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    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)))) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
                reservedmarshal_VkDescriptorImageInfo(
                    vkStream, rootType,
                    (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i), ptr);
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    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)))) {
            for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
                reservedmarshal_VkDescriptorBufferInfo(
                    vkStream, rootType,
                    (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i), ptr);
            }
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
    memcpy((*ptr), &cgen_var_3, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    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) {
                uint8_t* cgen_var_3_0_ptr = (uint8_t*)(*ptr);
                if (forMarshaling) {
                    for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k) {
                        uint64_t tmpval =
                            get_host_u64_VkBufferView(forMarshaling->pTexelBufferView[k]);
                        memcpy(cgen_var_3_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
                    }
                }
                *ptr += 8 * forMarshaling->descriptorCount;
            }
        }
    }
}

void reservedmarshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkAttachmentDescription* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags,
           sizeof(VkAttachmentDescriptionFlags));
    *ptr += sizeof(VkAttachmentDescriptionFlags);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    *ptr += sizeof(VkAttachmentLoadOp);
    memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    *ptr += sizeof(VkAttachmentStoreOp);
    memcpy(*ptr, (VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
    *ptr += sizeof(VkAttachmentLoadOp);
    memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
    *ptr += sizeof(VkAttachmentStoreOp);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkAttachmentReference* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkFramebufferCreateInfo* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFramebufferCreateFlags*)&forMarshaling->flags,
           sizeof(VkFramebufferCreateFlags));
    *ptr += sizeof(VkFramebufferCreateFlags);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkRenderPass((*&forMarshaling->renderPass));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
         (((forMarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
        if (forMarshaling->attachmentCount) {
            uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
            if (forMarshaling) {
                for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k) {
                    uint64_t tmpval = get_host_u64_VkImageView(forMarshaling->pAttachments[k]);
                    memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
                }
            }
            *ptr += 8 * forMarshaling->attachmentCount;
        }
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkSubpassDescription* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags,
           sizeof(VkSubpassDescriptionFlags));
    *ptr += sizeof(VkSubpassDescriptionFlags);
    memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
           sizeof(VkPipelineBindPoint));
    *ptr += sizeof(VkPipelineBindPoint);
    memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
        reservedmarshal_VkAttachmentReference(
            vkStream, rootType,
            (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
        reservedmarshal_VkAttachmentReference(
            vkStream, rootType,
            (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i), ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pResolveAttachments) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
            reservedmarshal_VkAttachmentReference(
                vkStream, rootType,
                (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i), ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDepthStencilAttachment) {
        reservedmarshal_VkAttachmentReference(
            vkStream, rootType,
            (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments,
           forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
    *ptr += forMarshaling->preserveAttachmentCount * sizeof(const uint32_t);
}

void reservedmarshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkSubpassDependency* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
    *ptr += sizeof(VkPipelineStageFlags);
    memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
    *ptr += sizeof(VkPipelineStageFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
    *ptr += sizeof(VkDependencyFlags);
}

void reservedmarshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkRenderPassCreateInfo* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
    *ptr += sizeof(VkRenderPassCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
        reservedmarshal_VkAttachmentDescription(
            vkStream, rootType, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
        reservedmarshal_VkSubpassDescription(
            vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
        reservedmarshal_VkSubpassDependency(
            vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i),
            ptr);
    }
}

void reservedmarshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkCommandPoolCreateInfo* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkCommandPoolCreateFlags*)&forMarshaling->flags,
           sizeof(VkCommandPoolCreateFlags));
    *ptr += sizeof(VkCommandPoolCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkCommandBufferAllocateInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkCommandPool((*&forMarshaling->commandPool));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
    *ptr += sizeof(VkCommandBufferLevel);
    memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkCommandBufferInheritanceInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkRenderPass((*&forMarshaling->renderPass));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkFramebuffer((*&forMarshaling->framebuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
    *ptr += sizeof(VkQueryControlFlags);
    memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
           sizeof(VkQueryPipelineStatisticFlags));
    *ptr += sizeof(VkQueryPipelineStatisticFlags);
}

void reservedmarshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkCommandBufferBeginInfo* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkCommandBufferUsageFlags*)&forMarshaling->flags,
           sizeof(VkCommandBufferUsageFlags));
    *ptr += sizeof(VkCommandBufferUsageFlags);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pInheritanceInfo) {
        reservedmarshal_VkCommandBufferInheritanceInfo(
            vkStream, rootType,
            (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo), ptr);
    }
}

void reservedmarshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkBufferCopy* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkImageSubresourceLayers* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkBufferImageCopy* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
}

void reservedmarshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkClearColorValue* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (float*)forMarshaling->float32, 4 * sizeof(float));
    *ptr += 4 * sizeof(float);
}

void reservedmarshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkClearDepthStencilValue* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (float*)&forMarshaling->depth, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkClearValue* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkClearColorValue(vkStream, rootType,
                                      (VkClearColorValue*)(&forMarshaling->color), ptr);
}

void reservedmarshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkClearAttachment* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue),
                                 ptr);
}

void reservedmarshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                 const VkClearRect* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->rect), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                 const VkImageBlit* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i),
                                   ptr);
    }
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i),
                                   ptr);
    }
}

void reservedmarshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                 const VkImageCopy* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}

void reservedmarshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                    const VkImageResolve* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}

void reservedmarshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkRenderPassBeginInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkRenderPass((*&forMarshaling->renderPass));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkFramebuffer((*&forMarshaling->framebuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pClearValues) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i) {
            reservedmarshal_VkClearValue(
                vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i), ptr);
        }
    }
}

#endif
#ifdef VK_VERSION_1_1
void reservedmarshal_VkPhysicalDeviceSubgroupProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
    *ptr += sizeof(VkShaderStageFlags);
    memcpy(*ptr, (VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations,
           sizeof(VkSubgroupFeatureFlags));
    *ptr += sizeof(VkSubgroupFeatureFlags);
    memcpy(*ptr, (VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkBindBufferMemoryInfo* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkBindImageMemoryInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevice16BitStorageFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkMemoryDedicatedRequirements(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMemoryDedicatedRequirements* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkMemoryDedicatedAllocateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMemoryDedicatedAllocateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkMemoryAllocateFlagsInfo* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
    *ptr += sizeof(VkMemoryAllocateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDeviceGroupRenderPassBeginInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceGroupRenderPassBeginInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i) {
        reservedmarshal_VkRect2D(vkStream, rootType,
                                 (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i), ptr);
    }
}

void reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceGroupCommandBufferBeginInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkDeviceGroupSubmitInfo* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices,
           forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
    *ptr += forMarshaling->waitSemaphoreCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pCommandBufferDeviceMasks,
           forMarshaling->commandBufferCount * sizeof(const uint32_t));
    *ptr += forMarshaling->commandBufferCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices,
           forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
    *ptr += forMarshaling->signalSemaphoreCount * sizeof(const uint32_t);
}

void reservedmarshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkDeviceGroupBindSparseInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkBindBufferMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices,
           forMarshaling->deviceIndexCount * sizeof(const uint32_t));
    *ptr += forMarshaling->deviceIndexCount * sizeof(const uint32_t);
}

void reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkBindImageMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices,
           forMarshaling->deviceIndexCount * sizeof(const uint32_t));
    *ptr += forMarshaling->deviceIndexCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i) {
        reservedmarshal_VkRect2D(vkStream, rootType,
                                 (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i),
                                 ptr);
    }
}

void reservedmarshal_VkPhysicalDeviceGroupProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceGroupProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkPhysicalDevice*)forMarshaling->physicalDevices,
           VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
    *ptr += VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice);
    memcpy(*ptr, (VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDeviceGroupDeviceCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceGroupDeviceCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->physicalDeviceCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->physicalDeviceCount; ++k) {
                uint64_t tmpval = get_host_u64_VkPhysicalDevice(forMarshaling->pPhysicalDevices[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->physicalDeviceCount;
    }
}

void reservedmarshal_VkBufferMemoryRequirementsInfo2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkBufferMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkImageMemoryRequirementsInfo2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImageMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImageSparseMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkMemoryRequirements2* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkMemoryRequirements(
        vkStream, rootType, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
}

void reservedmarshal_VkSparseImageMemoryRequirements2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSparseImageMemoryRequirements2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkSparseImageMemoryRequirements(
        vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements),
        ptr);
}

void reservedmarshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkPhysicalDeviceFeatures2* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkPhysicalDeviceFeatures(
        vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forMarshaling->features), ptr);
}

void reservedmarshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkPhysicalDeviceProperties2* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkPhysicalDeviceProperties(
        vkStream, rootType, (VkPhysicalDeviceProperties*)(&forMarshaling->properties), ptr);
}

void reservedmarshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkFormatProperties2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkFormatProperties(
        vkStream, rootType, (VkFormatProperties*)(&forMarshaling->formatProperties), ptr);
}

void reservedmarshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkImageFormatProperties2* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
}

void reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImageFormatInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkImageType*)&forMarshaling->type, sizeof(VkImageType));
    *ptr += sizeof(VkImageType);
    memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
    *ptr += sizeof(VkImageTiling);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
    *ptr += sizeof(VkImageCreateFlags);
}

void reservedmarshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkQueueFamilyProperties2* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkQueueFamilyProperties(
        vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties), ptr);
}

void reservedmarshal_VkPhysicalDeviceMemoryProperties2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMemoryProperties2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkPhysicalDeviceMemoryProperties(
        vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties),
        ptr);
}

void reservedmarshal_VkSparseImageFormatProperties2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSparseImageFormatProperties2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkSparseImageFormatProperties(
        vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties), ptr);
}

void reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkImageType*)&forMarshaling->type, sizeof(VkImageType));
    *ptr += sizeof(VkImageType);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
    *ptr += sizeof(VkImageTiling);
}

void reservedmarshal_VkPhysicalDevicePointClippingProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePointClippingProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
           sizeof(VkPointClippingBehavior));
    *ptr += sizeof(VkPointClippingBehavior);
}

void reservedmarshal_VkInputAttachmentAspectReference(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkInputAttachmentAspectReference* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
}

void reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i) {
        reservedmarshal_VkInputAttachmentAspectReference(
            vkStream, rootType,
            (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i), ptr);
    }
}

void reservedmarshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkImageViewUsageCreateInfo* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
}

void reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkTessellationDomainOrigin*)&forMarshaling->domainOrigin,
           sizeof(VkTessellationDomainOrigin));
    *ptr += sizeof(VkTessellationDomainOrigin);
}

void reservedmarshal_VkRenderPassMultiviewCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkRenderPassMultiviewCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pViewMasks,
           forMarshaling->subpassCount * sizeof(const uint32_t));
    *ptr += forMarshaling->subpassCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const int32_t*)forMarshaling->pViewOffsets,
           forMarshaling->dependencyCount * sizeof(const int32_t));
    *ptr += forMarshaling->dependencyCount * sizeof(const int32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelationMasks,
           forMarshaling->correlationMaskCount * sizeof(const uint32_t));
    *ptr += forMarshaling->correlationMaskCount * sizeof(const uint32_t);
}

void reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceMultiviewProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVariablePointersFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkDeviceQueueInfo2* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags,
           sizeof(VkDeviceQueueCreateFlags));
    *ptr += sizeof(VkDeviceQueueCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkProtectedSubmitInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSamplerYcbcrConversionCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel,
           sizeof(VkSamplerYcbcrModelConversion));
    *ptr += sizeof(VkSamplerYcbcrModelConversion);
    memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
    *ptr += sizeof(VkSamplerYcbcrRange);
    reservedmarshal_VkComponentMapping(vkStream, rootType,
                                       (VkComponentMapping*)(&forMarshaling->components), ptr);
    memcpy(*ptr, (VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
    *ptr += sizeof(VkChromaLocation);
    memcpy(*ptr, (VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
    *ptr += sizeof(VkChromaLocation);
    memcpy(*ptr, (VkFilter*)&forMarshaling->chromaFilter, sizeof(VkFilter));
    *ptr += sizeof(VkFilter);
    memcpy(*ptr, (VkBool32*)&forMarshaling->forceExplicitReconstruction, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkSamplerYcbcrConversionInfo* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSamplerYcbcrConversion((*&forMarshaling->conversion));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkBindImagePlaneMemoryInfo* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
           sizeof(VkImageAspectFlagBits));
    *ptr += sizeof(VkImageAspectFlagBits);
}

void reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImagePlaneMemoryRequirementsInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
           sizeof(VkImageAspectFlagBits));
    *ptr += sizeof(VkImageAspectFlagBits);
}

void reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDescriptorUpdateTemplateEntry(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorUpdateTemplateEntry* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    *ptr += sizeof(VkDescriptorType);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->offset;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->stride;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

void reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorUpdateTemplateCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags,
           sizeof(VkDescriptorUpdateTemplateCreateFlags));
    *ptr += sizeof(VkDescriptorUpdateTemplateCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i) {
        reservedmarshal_VkDescriptorUpdateTemplateEntry(
            vkStream, rootType,
            (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i),
            ptr);
    }
    memcpy(*ptr, (VkDescriptorUpdateTemplateType*)&forMarshaling->templateType,
           sizeof(VkDescriptorUpdateTemplateType));
    *ptr += sizeof(VkDescriptorUpdateTemplateType);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDescriptorSetLayout((*&forMarshaling->descriptorSetLayout));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
           sizeof(VkPipelineBindPoint));
    *ptr += sizeof(VkPipelineBindPoint);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkPipelineLayout((*&forMarshaling->pipelineLayout));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->set, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkExternalMemoryProperties* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures,
           sizeof(VkExternalMemoryFeatureFlags));
    *ptr += sizeof(VkExternalMemoryFeatureFlags);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
           sizeof(VkExternalMemoryHandleTypeFlags));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlags);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
           sizeof(VkExternalMemoryHandleTypeFlags));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}

void reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}

void reservedmarshal_VkExternalImageFormatProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalImageFormatProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkExternalMemoryProperties(
        vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties),
        ptr);
}

void reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalBufferInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
    *ptr += sizeof(VkBufferCreateFlags);
    memcpy(*ptr, (VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
    *ptr += sizeof(VkBufferUsageFlags);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}

void reservedmarshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkExternalBufferProperties* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkExternalMemoryProperties(
        vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties),
        ptr);
}

void reservedmarshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkPhysicalDeviceIDProperties* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
    *ptr += VK_LUID_SIZE * sizeof(uint8_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkExternalMemoryImageCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalMemoryImageCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
           sizeof(VkExternalMemoryHandleTypeFlags));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}

void reservedmarshal_VkExternalMemoryBufferCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalMemoryBufferCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
           sizeof(VkExternalMemoryHandleTypeFlags));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}

void reservedmarshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkExportMemoryAllocateInfo* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
           sizeof(VkExternalMemoryHandleTypeFlags));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}

void reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalFenceInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalFenceHandleTypeFlagBits));
    *ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}

void reservedmarshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkExternalFenceProperties* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
           sizeof(VkExternalFenceHandleTypeFlags));
    *ptr += sizeof(VkExternalFenceHandleTypeFlags);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
           sizeof(VkExternalFenceHandleTypeFlags));
    *ptr += sizeof(VkExternalFenceHandleTypeFlags);
    memcpy(*ptr, (VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures,
           sizeof(VkExternalFenceFeatureFlags));
    *ptr += sizeof(VkExternalFenceFeatureFlags);
}

void reservedmarshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkExportFenceCreateInfo* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes,
           sizeof(VkExternalFenceHandleTypeFlags));
    *ptr += sizeof(VkExternalFenceHandleTypeFlags);
}

void reservedmarshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkExportSemaphoreCreateInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes,
           sizeof(VkExternalSemaphoreHandleTypeFlags));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
}

void reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}

void reservedmarshal_VkExternalSemaphoreProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalSemaphoreProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
           sizeof(VkExternalSemaphoreHandleTypeFlags));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
           sizeof(VkExternalSemaphoreHandleTypeFlags));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
    memcpy(*ptr, (VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures,
           sizeof(VkExternalSemaphoreFeatureFlags));
    *ptr += sizeof(VkExternalSemaphoreFeatureFlags);
}

void reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance3Properties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkDescriptorSetLayoutSupport* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_VERSION_1_2
void reservedmarshal_VkPhysicalDeviceVulkan11Features(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkan11Features* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

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

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

void reservedmarshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkConformanceVersion* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint8_t*)&forMarshaling->major, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->minor, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->subminor, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->patch, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
}

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

void reservedmarshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkImageFormatListCreateInfo* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats,
           forMarshaling->viewFormatCount * sizeof(const VkFormat));
    *ptr += forMarshaling->viewFormatCount * sizeof(const VkFormat);
}

void reservedmarshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkAttachmentDescription2* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags,
           sizeof(VkAttachmentDescriptionFlags));
    *ptr += sizeof(VkAttachmentDescriptionFlags);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    *ptr += sizeof(VkAttachmentLoadOp);
    memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    *ptr += sizeof(VkAttachmentStoreOp);
    memcpy(*ptr, (VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
    *ptr += sizeof(VkAttachmentLoadOp);
    memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
    *ptr += sizeof(VkAttachmentStoreOp);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkAttachmentReference2* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
    *ptr += sizeof(VkImageAspectFlags);
}

void reservedmarshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkSubpassDescription2* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags,
           sizeof(VkSubpassDescriptionFlags));
    *ptr += sizeof(VkSubpassDescriptionFlags);
    memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
           sizeof(VkPipelineBindPoint));
    *ptr += sizeof(VkPipelineBindPoint);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
        reservedmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
        reservedmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i), ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pResolveAttachments) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
            reservedmarshal_VkAttachmentReference2(
                vkStream, rootType,
                (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i), ptr);
        }
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDepthStencilAttachment) {
        reservedmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments,
           forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
    *ptr += forMarshaling->preserveAttachmentCount * sizeof(const uint32_t);
}

void reservedmarshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkSubpassDependency2* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
    *ptr += sizeof(VkPipelineStageFlags);
    memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
    *ptr += sizeof(VkPipelineStageFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
    *ptr += sizeof(VkAccessFlags);
    memcpy(*ptr, (VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
    *ptr += sizeof(VkDependencyFlags);
    memcpy(*ptr, (int32_t*)&forMarshaling->viewOffset, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkRenderPassCreateInfo2* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
    *ptr += sizeof(VkRenderPassCreateFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
        reservedmarshal_VkAttachmentDescription2(
            vkStream, rootType, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
        reservedmarshal_VkSubpassDescription2(
            vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
        reservedmarshal_VkSubpassDependency2(
            vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelatedViewMasks,
           forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
    *ptr += forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t);
}

void reservedmarshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkSubpassBeginInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
    *ptr += sizeof(VkSubpassContents);
}

void reservedmarshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkSubpassEndInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}

void reservedmarshal_VkPhysicalDevice8BitStorageFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevice8BitStorageFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceDriverProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDriverProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
    *ptr += sizeof(VkDriverId);
    memcpy(*ptr, (char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
    *ptr += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
    *ptr += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
    reservedmarshal_VkConformanceVersion(
        vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
}

void reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFloatControlsProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
           sizeof(VkShaderFloatControlsIndependence));
    *ptr += sizeof(VkShaderFloatControlsIndependence);
    memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
           sizeof(VkShaderFloatControlsIndependence));
    *ptr += sizeof(VkShaderFloatControlsIndependence);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat32, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormFlushToZeroFloat64, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat32, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTEFloat64, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pBindingFlags;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pBindingFlags) {
        memcpy(*ptr, (const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags,
               forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
        *ptr += forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags);
    }
}

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

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

void reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pDescriptorCounts,
           forMarshaling->descriptorSetCount * sizeof(const uint32_t));
    *ptr += forMarshaling->descriptorSetCount * sizeof(const uint32_t);
}

void reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSubpassDescriptionDepthStencilResolve* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->depthResolveMode,
           sizeof(VkResolveModeFlagBits));
    *ptr += sizeof(VkResolveModeFlagBits);
    memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode,
           sizeof(VkResolveModeFlagBits));
    *ptr += sizeof(VkResolveModeFlagBits);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilResolveAttachment;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDepthStencilResolveAttachment) {
        reservedmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment), ptr);
    }
}

void reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
           sizeof(VkResolveModeFlags));
    *ptr += sizeof(VkResolveModeFlags);
    memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
           sizeof(VkResolveModeFlags));
    *ptr += sizeof(VkResolveModeFlags);
    memcpy(*ptr, (VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->independentResolve, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkImageStencilUsageCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImageStencilUsageCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->stencilUsage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
}

void reservedmarshal_VkSamplerReductionModeCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSamplerReductionModeCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSamplerReductionMode*)&forMarshaling->reductionMode,
           sizeof(VkSamplerReductionMode));
    *ptr += sizeof(VkSamplerReductionMode);
}

void reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->imagelessFramebuffer, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkFramebufferAttachmentImageInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkFramebufferAttachmentImageInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
    *ptr += sizeof(VkImageCreateFlags);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats,
           forMarshaling->viewFormatCount * sizeof(const VkFormat));
    *ptr += forMarshaling->viewFormatCount * sizeof(const VkFormat);
}

void reservedmarshal_VkFramebufferAttachmentsCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkFramebufferAttachmentsCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentImageInfoCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i) {
        reservedmarshal_VkFramebufferAttachmentImageInfo(
            vkStream, rootType,
            (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i),
            ptr);
    }
}

void reservedmarshal_VkRenderPassAttachmentBeginInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkRenderPassAttachmentBeginInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->attachmentCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k) {
                uint64_t tmpval = get_host_u64_VkImageView(forMarshaling->pAttachments[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->attachmentCount;
    }
}

void reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkAttachmentReferenceStencilLayout(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkAttachmentReferenceStencilLayout* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkAttachmentDescriptionStencilLayout(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkAttachmentDescriptionStencilLayout* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilInitialLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilFinalLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->hostQueryReset, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->timelineSemaphore, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkSemaphoreTypeCreateInfo* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSemaphoreType*)&forMarshaling->semaphoreType, sizeof(VkSemaphoreType));
    *ptr += sizeof(VkSemaphoreType);
    memcpy(*ptr, (uint64_t*)&forMarshaling->initialValue, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkTimelineSemaphoreSubmitInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkTimelineSemaphoreSubmitInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pWaitSemaphoreValues) {
        memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues,
               forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
        *ptr += forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSignalSemaphoreValues) {
        memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues,
               forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
        *ptr += forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t);
    }
}

void reservedmarshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkSemaphoreWaitInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSemaphoreWaitFlags*)&forMarshaling->flags, sizeof(VkSemaphoreWaitFlags));
    *ptr += sizeof(VkSemaphoreWaitFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->semaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->semaphoreCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->semaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSemaphores[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->semaphoreCount;
    }
    memcpy(*ptr, (const uint64_t*)forMarshaling->pValues,
           forMarshaling->semaphoreCount * sizeof(const uint64_t));
    *ptr += forMarshaling->semaphoreCount * sizeof(const uint64_t);
}

void reservedmarshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkSemaphoreSignalInfo* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint64_t*)&forMarshaling->value, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkBufferDeviceAddressInfo* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

#endif
#ifdef VK_KHR_surface
void reservedmarshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkSurfaceCapabilitiesKHR* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent),
                               ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
           sizeof(VkSurfaceTransformFlagsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagsKHR);
    memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
           sizeof(VkSurfaceTransformFlagBitsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
    memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
           sizeof(VkCompositeAlphaFlagsKHR));
    *ptr += sizeof(VkCompositeAlphaFlagsKHR);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
           sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
}

void reservedmarshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkSurfaceFormatKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
    *ptr += sizeof(VkColorSpaceKHR);
}

#endif
#ifdef VK_KHR_swapchain
void reservedmarshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkSwapchainCreateInfoKHR* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSwapchainCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkSwapchainCreateFlagsKHR));
    *ptr += sizeof(VkSwapchainCreateFlagsKHR);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSurfaceKHR((*&forMarshaling->surface));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
    *ptr += sizeof(VkColorSpaceKHR);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
    *ptr += sizeof(VkSharingMode);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pQueueFamilyIndices) {
        memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
               forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
        *ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
    }
    memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform,
           sizeof(VkSurfaceTransformFlagBitsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
    memcpy(*ptr, (VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha,
           sizeof(VkCompositeAlphaFlagBitsKHR));
    *ptr += sizeof(VkCompositeAlphaFlagBitsKHR);
    memcpy(*ptr, (VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
    *ptr += sizeof(VkPresentModeKHR);
    memcpy(*ptr, (VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    uint64_t cgen_var_2;
    *&cgen_var_2 = get_host_u64_VkSwapchainKHR((*&forMarshaling->oldSwapchain));
    memcpy(*ptr, (uint64_t*)&cgen_var_2, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkPresentInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->waitSemaphoreCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->waitSemaphoreCount;
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->swapchainCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->swapchainCount; ++k) {
                uint64_t tmpval = get_host_u64_VkSwapchainKHR(forMarshaling->pSwapchains[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->swapchainCount;
    }
    memcpy(*ptr, (const uint32_t*)forMarshaling->pImageIndices,
           forMarshaling->swapchainCount * sizeof(const uint32_t));
    *ptr += forMarshaling->swapchainCount * sizeof(const uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pResults;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pResults) {
        memcpy(*ptr, (VkResult*)forMarshaling->pResults,
               forMarshaling->swapchainCount * sizeof(VkResult));
        *ptr += forMarshaling->swapchainCount * sizeof(VkResult);
    }
}

void reservedmarshal_VkImageSwapchainCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImageSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSwapchainKHR((*&forMarshaling->swapchain));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkBindImageMemorySwapchainInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSwapchainKHR((*&forMarshaling->swapchain));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkAcquireNextImageInfoKHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSwapchainKHR((*&forMarshaling->swapchain));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_2;
    *&cgen_var_2 = get_host_u64_VkFence((*&forMarshaling->fence));
    memcpy(*ptr, (uint64_t*)&cgen_var_2, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)forMarshaling->presentMask,
           VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
    *ptr += VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t);
    memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
           sizeof(VkDeviceGroupPresentModeFlagsKHR));
    *ptr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}

void reservedmarshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkDeviceGroupPresentInfoKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceMasks,
           forMarshaling->swapchainCount * sizeof(const uint32_t));
    *ptr += forMarshaling->swapchainCount * sizeof(const uint32_t);
    memcpy(*ptr, (VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode,
           sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
    *ptr += sizeof(VkDeviceGroupPresentModeFlagBitsKHR);
}

void reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
           sizeof(VkDeviceGroupPresentModeFlagsKHR));
    *ptr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}

#endif
#ifdef VK_KHR_display
void reservedmarshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkDisplayModeParametersKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->visibleRegion),
                               ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkDisplayModeCreateInfoKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkDisplayModeCreateFlagsKHR));
    *ptr += sizeof(VkDisplayModeCreateFlagsKHR);
    reservedmarshal_VkDisplayModeParametersKHR(
        vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
}

void reservedmarshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkDisplayModePropertiesKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDisplayModeKHR((*&forMarshaling->displayMode));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    reservedmarshal_VkDisplayModeParametersKHR(
        vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
}

void reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDisplayPlaneCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha,
           sizeof(VkDisplayPlaneAlphaFlagsKHR));
    *ptr += sizeof(VkDisplayPlaneAlphaFlagsKHR);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition),
                               ptr);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSrcExtent),
                               ptr);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minDstPosition),
                               ptr);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxDstPosition),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minDstExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent),
                               ptr);
}

void reservedmarshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkDisplayPlanePropertiesKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDisplayKHR((*&forMarshaling->currentDisplay));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkDisplayPropertiesKHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDisplayKHR((*&forMarshaling->display));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    {
        uint32_t l = forMarshaling->displayName ? strlen(forMarshaling->displayName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->displayName, l);
        *ptr += l;
    }
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->physicalDimensions), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->physicalResolution), ptr);
    memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
           sizeof(VkSurfaceTransformFlagsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagsKHR);
    memcpy(*ptr, (VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDisplaySurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkDisplaySurfaceCreateFlagsKHR));
    *ptr += sizeof(VkDisplaySurfaceCreateFlagsKHR);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDisplayModeKHR((*&forMarshaling->displayMode));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
           sizeof(VkSurfaceTransformFlagBitsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
    memcpy(*ptr, (float*)&forMarshaling->globalAlpha, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode,
           sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
    *ptr += sizeof(VkDisplayPlaneAlphaFlagBitsKHR);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
}

#endif
#ifdef VK_KHR_display_swapchain
void reservedmarshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkDisplayPresentInfoKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->srcRect), ptr);
    reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->dstRect), ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_xlib_surface
void reservedmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkXlibSurfaceCreateInfoKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkXlibSurfaceCreateFlagsKHR));
    *ptr += sizeof(VkXlibSurfaceCreateFlagsKHR);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dpy;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->dpy) {
        memcpy(*ptr, (Display*)forMarshaling->dpy, sizeof(Display));
        *ptr += sizeof(Display);
    }
    memcpy(*ptr, (Window*)&forMarshaling->window, sizeof(Window));
    *ptr += sizeof(Window);
}

#endif
#ifdef VK_KHR_xcb_surface
void reservedmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkXcbSurfaceCreateInfoKHR* forMarshaling,
                                               uint8_t** ptr) {
    // This struct should never be marshaled / unmarshaled.
    __builtin_trap();
}

#endif
#ifdef VK_KHR_wayland_surface
void reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkWaylandSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkWaylandSurfaceCreateFlagsKHR));
    *ptr += sizeof(VkWaylandSurfaceCreateFlagsKHR);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->display;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->display) {
        memcpy(*ptr, (wl_display*)forMarshaling->display, sizeof(wl_display));
        *ptr += sizeof(wl_display);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->surface;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->surface) {
        memcpy(*ptr, (wl_surface*)forMarshaling->surface, sizeof(wl_surface));
        *ptr += sizeof(wl_surface);
    }
}

#endif
#ifdef VK_KHR_android_surface
void reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkAndroidSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkAndroidSurfaceCreateFlagsKHR));
    *ptr += sizeof(VkAndroidSurfaceCreateFlagsKHR);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->window) {
        memcpy(*ptr, (ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
        *ptr += sizeof(ANativeWindow);
    }
}

#endif
#ifdef VK_KHR_win32_surface
void reservedmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkWin32SurfaceCreateInfoKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkWin32SurfaceCreateFlagsKHR));
    *ptr += sizeof(VkWin32SurfaceCreateFlagsKHR);
    memcpy(*ptr, (HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
    *ptr += sizeof(HINSTANCE);
    memcpy(*ptr, (HWND*)&forMarshaling->hwnd, sizeof(HWND));
    *ptr += sizeof(HWND);
}

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void reservedmarshal_VkVideoQueueFamilyProperties2KHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoQueueFamilyProperties2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations,
           sizeof(VkVideoCodecOperationFlagsKHR));
    *ptr += sizeof(VkVideoCodecOperationFlagsKHR);
}

void reservedmarshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkVideoProfileKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation,
           sizeof(VkVideoCodecOperationFlagBitsKHR));
    *ptr += sizeof(VkVideoCodecOperationFlagBitsKHR);
    memcpy(*ptr, (VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling,
           sizeof(VkVideoChromaSubsamplingFlagsKHR));
    *ptr += sizeof(VkVideoChromaSubsamplingFlagsKHR);
    memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth,
           sizeof(VkVideoComponentBitDepthFlagsKHR));
    *ptr += sizeof(VkVideoComponentBitDepthFlagsKHR);
    memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth,
           sizeof(VkVideoComponentBitDepthFlagsKHR));
    *ptr += sizeof(VkVideoComponentBitDepthFlagsKHR);
}

void reservedmarshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkVideoProfilesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->profileCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkVideoProfileKHR(vkStream, rootType,
                                      (const VkVideoProfileKHR*)(forMarshaling->pProfiles), ptr);
}

void reservedmarshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkVideoCapabilitiesKHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags,
           sizeof(VkVideoCapabilityFlagsKHR));
    *ptr += sizeof(VkVideoCapabilityFlagsKHR);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment,
           sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment,
           sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minExtent), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxExtent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    reservedmarshal_VkVideoProfilesKHR(
        vkStream, rootType, (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles), ptr);
}

void reservedmarshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkVideoFormatPropertiesKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
}

void reservedmarshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkVideoPictureResourceKHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->codedOffset), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageViewBinding));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkVideoReferenceSlotKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
    *ptr += sizeof(int8_t);
    reservedmarshal_VkVideoPictureResourceKHR(
        vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource),
        ptr);
}

void reservedmarshal_VkVideoGetMemoryPropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoGetMemoryPropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkMemoryRequirements2(
        vkStream, rootType, (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements), ptr);
}

void reservedmarshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkVideoBindMemoryKHR* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->memorySize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkVideoSessionCreateInfoKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags,
           sizeof(VkVideoSessionCreateFlagsKHR));
    *ptr += sizeof(VkVideoSessionCreateFlagsKHR);
    reservedmarshal_VkVideoProfileKHR(
        vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile), ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->pictureFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent),
                               ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->referencePicturesFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkVideoSessionParametersCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoSessionParametersCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSessionParametersTemplate;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSession;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

void reservedmarshal_VkVideoSessionParametersUpdateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoSessionParametersUpdateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->updateSequenceCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkVideoBeginCodingInfoKHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags,
           sizeof(VkVideoBeginCodingFlagsKHR));
    *ptr += sizeof(VkVideoBeginCodingFlagsKHR);
    memcpy(*ptr, (VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset,
           sizeof(VkVideoCodingQualityPresetFlagsKHR));
    *ptr += sizeof(VkVideoCodingQualityPresetFlagsKHR);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSession;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSessionParameters;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
        reservedmarshal_VkVideoReferenceSlotKHR(
            vkStream, rootType,
            (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
    }
}

void reservedmarshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkVideoEndCodingInfoKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEndCodingFlagsKHR*)&forMarshaling->flags,
           sizeof(VkVideoEndCodingFlagsKHR));
    *ptr += sizeof(VkVideoEndCodingFlagsKHR);
}

void reservedmarshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkVideoCodingControlInfoKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoCodingControlFlagsKHR*)&forMarshaling->flags,
           sizeof(VkVideoCodingControlFlagsKHR));
    *ptr += sizeof(VkVideoCodingControlFlagsKHR);
}

#endif
#ifdef VK_KHR_video_decode_queue
void reservedmarshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkVideoDecodeInfoKHR* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoDecodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoDecodeFlagsKHR));
    *ptr += sizeof(VkVideoDecodeFlagsKHR);
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->codedOffset), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent), ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->srcBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcBufferOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcBufferRange, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    reservedmarshal_VkVideoPictureResourceKHR(
        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource), ptr);
    reservedmarshal_VkVideoReferenceSlotKHR(
        vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot),
        ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
        reservedmarshal_VkVideoReferenceSlotKHR(
            vkStream, rootType,
            (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
    }
}

#endif
#ifdef VK_KHR_dynamic_rendering
void reservedmarshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkRenderingAttachmentInfoKHR* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->resolveMode,
           sizeof(VkResolveModeFlagBits));
    *ptr += sizeof(VkResolveModeFlagBits);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImageView((*&forMarshaling->resolveImageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->resolveImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
    *ptr += sizeof(VkAttachmentLoadOp);
    memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
    *ptr += sizeof(VkAttachmentStoreOp);
    reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue),
                                 ptr);
}

void reservedmarshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkRenderingInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkRenderingFlagsKHR*)&forMarshaling->flags, sizeof(VkRenderingFlagsKHR));
    *ptr += sizeof(VkRenderingFlagsKHR);
    reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
        reservedmarshal_VkRenderingAttachmentInfoKHR(
            vkStream, rootType,
            (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i), ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDepthAttachment) {
        reservedmarshal_VkRenderingAttachmentInfoKHR(
            vkStream, rootType,
            (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment), ptr);
    }
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pStencilAttachment) {
        reservedmarshal_VkRenderingAttachmentInfoKHR(
            vkStream, rootType,
            (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment), ptr);
    }
}

void reservedmarshal_VkPipelineRenderingCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRenderingCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
           forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
    *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
    memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
}

void reservedmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkRenderingFlagsKHR*)&forMarshaling->flags, sizeof(VkRenderingFlagsKHR));
    *ptr += sizeof(VkRenderingFlagsKHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
           forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
    *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
    memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
           sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
}

void reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
}

void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
}

void reservedmarshal_VkAttachmentSampleCountInfoAMD(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkAttachmentSampleCountInfoAMD* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentSamples;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pColorAttachmentSamples) {
        memcpy(*ptr, (const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
               forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
        *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
    }
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
           sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
}

void reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMultiviewPerViewAttributesInfoNVX* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->perViewAttributes, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
    *ptr += 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 reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
    memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    *ptr += sizeof(HANDLE);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pAttributes) {
        memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
               sizeof(const SECURITY_ATTRIBUTES));
        *ptr += sizeof(const SECURITY_ATTRIBUTES);
    }
    memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    *ptr += sizeof(DWORD);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMemoryWin32HandlePropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkMemoryGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_external_memory_fd
void reservedmarshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkImportMemoryFdInfoKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
    memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
    *ptr += sizeof(int);
}

void reservedmarshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkMemoryFdPropertiesKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkMemoryGetFdInfoKHR* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagBits));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->acquireCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pAcquireSyncs[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->acquireCount;
    }
    memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys,
           forMarshaling->acquireCount * sizeof(const uint64_t));
    *ptr += forMarshaling->acquireCount * sizeof(const uint64_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeouts,
           forMarshaling->acquireCount * sizeof(const uint32_t));
    *ptr += forMarshaling->acquireCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->releaseCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pReleaseSyncs[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->releaseCount;
    }
    memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys,
           forMarshaling->releaseCount * sizeof(const uint64_t));
    *ptr += forMarshaling->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 reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
    *ptr += sizeof(VkSemaphoreImportFlags);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
    memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    *ptr += sizeof(HANDLE);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pAttributes) {
        memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
               sizeof(const SECURITY_ATTRIBUTES));
        *ptr += sizeof(const SECURITY_ATTRIBUTES);
    }
    memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    *ptr += sizeof(DWORD);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkD3D12FenceSubmitInfoKHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pWaitSemaphoreValues) {
        memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues,
               forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
        *ptr += forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSignalSemaphoreValues) {
        memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues,
               forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
        *ptr += forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t);
    }
}

void reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_external_semaphore_fd
void reservedmarshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkImportSemaphoreFdInfoKHR* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
    *ptr += sizeof(VkSemaphoreImportFlags);
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
    memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
    *ptr += sizeof(int);
}

void reservedmarshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkSemaphoreGetFdInfoKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalSemaphoreHandleTypeFlagBits));
    *ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_push_descriptor
void reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

#endif
#ifdef VK_KHR_shader_float16_int8
#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
void reservedmarshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                    const VkRectLayerKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkPresentRegionKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pRectangles) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i) {
            reservedmarshal_VkRectLayerKHR(
                vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i), ptr);
        }
    }
}

void reservedmarshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkPresentRegionsKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pRegions) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
            reservedmarshal_VkPresentRegionKHR(
                vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i), ptr);
        }
    }
}

#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 reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags,
           sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
}

#endif
#ifdef VK_KHR_external_fence_capabilities
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
void reservedmarshal_VkImportFenceWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
    *ptr += sizeof(VkFenceImportFlags);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalFenceHandleTypeFlagBits));
    *ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
    memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    *ptr += sizeof(HANDLE);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkExportFenceWin32HandleInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pAttributes) {
        memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
               sizeof(const SECURITY_ATTRIBUTES));
        *ptr += sizeof(const SECURITY_ATTRIBUTES);
    }
    memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    *ptr += sizeof(DWORD);
    memcpy(*ptr, (LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
    *ptr += sizeof(LPCWSTR);
}

void reservedmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkFenceGetWin32HandleInfoKHR* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalFenceHandleTypeFlagBits));
    *ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_external_fence_fd
void reservedmarshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkImportFenceFdInfoKHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
    *ptr += sizeof(VkFenceImportFlags);
    memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalFenceHandleTypeFlagBits));
    *ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
    memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
    *ptr += sizeof(int);
}

void reservedmarshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkFenceGetFdInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
           sizeof(VkExternalFenceHandleTypeFlagBits));
    *ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}

#endif
#ifdef VK_KHR_performance_query
void reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->performanceCounterQueryPools, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->performanceCounterMultipleQueryPools, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkPerformanceCounterKHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPerformanceCounterUnitKHR*)&forMarshaling->unit,
           sizeof(VkPerformanceCounterUnitKHR));
    *ptr += sizeof(VkPerformanceCounterUnitKHR);
    memcpy(*ptr, (VkPerformanceCounterScopeKHR*)&forMarshaling->scope,
           sizeof(VkPerformanceCounterScopeKHR));
    *ptr += sizeof(VkPerformanceCounterScopeKHR);
    memcpy(*ptr, (VkPerformanceCounterStorageKHR*)&forMarshaling->storage,
           sizeof(VkPerformanceCounterStorageKHR));
    *ptr += sizeof(VkPerformanceCounterStorageKHR);
    memcpy(*ptr, (uint8_t*)forMarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
}

void reservedmarshal_VkPerformanceCounterDescriptionKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPerformanceCounterDescriptionKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags,
           sizeof(VkPerformanceCounterDescriptionFlagsKHR));
    *ptr += sizeof(VkPerformanceCounterDescriptionFlagsKHR);
    memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
}

void reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->counterIndexCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pCounterIndices,
           forMarshaling->counterIndexCount * sizeof(const uint32_t));
    *ptr += forMarshaling->counterIndexCount * sizeof(const uint32_t);
}

void reservedmarshal_VkPerformanceCounterResultKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPerformanceCounterResultKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (int32_t*)&forMarshaling->int32, sizeof(int32_t));
    *ptr += sizeof(int32_t);
}

void reservedmarshal_VkAcquireProfilingLockInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkAcquireProfilingLockInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags,
           sizeof(VkAcquireProfilingLockFlagsKHR));
    *ptr += sizeof(VkAcquireProfilingLockFlagsKHR);
    memcpy(*ptr, (uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPerformanceQuerySubmitInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->counterPassIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
void reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSurfaceKHR((*&forMarshaling->surface));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkSurfaceCapabilities2KHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkSurfaceCapabilitiesKHR(
        vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities), ptr);
}

void reservedmarshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkSurfaceFormat2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkSurfaceFormatKHR(vkStream, rootType,
                                       (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat), ptr);
}

#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
void reservedmarshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkDisplayProperties2KHR* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkDisplayPropertiesKHR(
        vkStream, rootType, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties), ptr);
}

void reservedmarshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkDisplayPlaneProperties2KHR* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkDisplayPlanePropertiesKHR(
        vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties),
        ptr);
}

void reservedmarshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkDisplayModeProperties2KHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkDisplayModePropertiesKHR(
        vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties),
        ptr);
}

void reservedmarshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkDisplayPlaneInfo2KHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkDisplayModeKHR((*&forMarshaling->mode));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkDisplayPlaneCapabilities2KHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDisplayPlaneCapabilities2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
        vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities), ptr);
}

#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 reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->events, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->imageViewFormatReinterpretation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->imageViewFormatSwizzle, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->imageView2DOn3DImage, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->multisampleArrayImage, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->mutableComparisonSamplers, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->pointPolygons, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->samplerMipLodBias, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->separateStencilMaskRef, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->tessellationIsolines, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->tessellationPointMode, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->triangleFans, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeAccessBeyondStride, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->minVertexInputBindingStrideAlignment, sizeof(uint32_t));
    *ptr += 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 reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupClock, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDeviceClock, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_driver_properties
#endif
#ifdef VK_KHR_shader_float_controls
#endif
#ifdef VK_KHR_depth_stencil_resolve
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
#endif
#ifdef VK_KHR_vulkan_memory_model
#endif
#ifdef VK_KHR_shader_terminate_invocation
void reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_fragment_shading_rate
void reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pFragmentShadingRateAttachment;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pFragmentShadingRateAttachment) {
        reservedmarshal_VkAttachmentReference2(
            vkStream, rootType,
            (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment), ptr);
    }
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
}

void reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize),
                               ptr);
    memcpy(*ptr, (VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
           2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
    *ptr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}

void reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->attachmentFragmentShadingRate, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkExtent2D(
        vkStream, rootType,
        (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize), ptr);
    reservedmarshal_VkExtent2D(
        vkStream, rootType,
        (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
           sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentSize),
                               ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples,
           sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples,
           sizeof(VkSampleCountFlagBits));
    *ptr += sizeof(VkSampleCountFlagBits);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithSampleMask, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
    *ptr += sizeof(VkSampleCountFlags);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize),
                               ptr);
}

#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSurfaceProtectedCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->supportsProtected, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_present_wait
void reservedmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->presentWait, sizeof(VkBool32));
    *ptr += 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 reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineExecutableInfo, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkPipelineInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkPipeline((*&forMarshaling->pipeline));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkPipelineExecutablePropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineExecutablePropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stages, sizeof(VkShaderStageFlags));
    *ptr += sizeof(VkShaderStageFlags);
    memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkPipelineExecutableInfoKHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkPipeline((*&forMarshaling->pipeline));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->executableIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineExecutableStatisticValueKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineExecutableStatisticValueKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkBool32*)&forMarshaling->b32, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineExecutableStatisticKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineExecutableStatisticKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format,
           sizeof(VkPipelineExecutableStatisticFormatKHR));
    *ptr += sizeof(VkPipelineExecutableStatisticFormatKHR);
    reservedmarshal_VkPipelineExecutableStatisticValueKHR(
        vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value), ptr);
}

void reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineExecutableInternalRepresentationKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
    memcpy(*ptr, (VkBool32*)&forMarshaling->isText, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pData;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pData) {
        memcpy(*ptr, (void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(uint8_t));
        *ptr += forMarshaling->dataSize * sizeof(uint8_t);
    }
}

#endif
#ifdef VK_KHR_shader_integer_dot_product
void reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

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

#endif
#ifdef VK_KHR_pipeline_library
void reservedmarshal_VkPipelineLibraryCreateInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineLibraryCreateInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->libraryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->libraryCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->libraryCount; ++k) {
                uint64_t tmpval = get_host_u64_VkPipeline(forMarshaling->pLibraries[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->libraryCount;
    }
}

#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
void reservedmarshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                    const VkPresentIdKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPresentIds;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pPresentIds) {
        memcpy(*ptr, (const uint64_t*)forMarshaling->pPresentIds,
               forMarshaling->swapchainCount * sizeof(const uint64_t));
        *ptr += forMarshaling->swapchainCount * sizeof(const uint64_t);
    }
}

void reservedmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->presentId, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_video_encode_queue
void reservedmarshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkVideoEncodeInfoKHR* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEncodeFlagsKHR));
    *ptr += sizeof(VkVideoEncodeFlagsKHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->qualityLevel, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent), ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->dstBitstreamBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstBitstreamBufferOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstBitstreamBufferMaxRange, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    reservedmarshal_VkVideoPictureResourceKHR(
        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource), ptr);
    reservedmarshal_VkVideoReferenceSlotKHR(
        vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot),
        ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
        reservedmarshal_VkVideoReferenceSlotKHR(
            vkStream, rootType,
            (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
    }
}

void reservedmarshal_VkVideoEncodeRateControlInfoKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeRateControlInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
           sizeof(VkVideoEncodeRateControlFlagsKHR));
    *ptr += sizeof(VkVideoEncodeRateControlFlagsKHR);
    memcpy(*ptr, (VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
           sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
    *ptr += sizeof(VkVideoEncodeRateControlModeFlagBitsKHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->averageBitrate, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint16_t*)&forMarshaling->peakToAverageBitrateRatio, sizeof(uint16_t));
    *ptr += sizeof(uint16_t);
    memcpy(*ptr, (uint16_t*)&forMarshaling->frameRateNumerator, sizeof(uint16_t));
    *ptr += sizeof(uint16_t);
    memcpy(*ptr, (uint16_t*)&forMarshaling->frameRateDenominator, sizeof(uint16_t));
    *ptr += sizeof(uint16_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

#endif
#ifdef VK_KHR_synchronization2
void reservedmarshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkMemoryBarrier2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
}

void reservedmarshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkBufferMemoryBarrier2KHR* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkImageMemoryBarrier2KHR* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
    *ptr += sizeof(VkAccessFlags2KHR);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    reservedmarshal_VkImageSubresourceRange(
        vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}

void reservedmarshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkDependencyInfoKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
    *ptr += sizeof(VkDependencyFlags);
    memcpy(*ptr, (uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
        reservedmarshal_VkMemoryBarrier2KHR(
            vkStream, rootType, (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
        reservedmarshal_VkBufferMemoryBarrier2KHR(
            vkStream, rootType,
            (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
        reservedmarshal_VkImageMemoryBarrier2KHR(
            vkStream, rootType,
            (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i), ptr);
    }
}

void reservedmarshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkSemaphoreSubmitInfoKHR* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint64_t*)&forMarshaling->value, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkCommandBufferSubmitInfoKHR* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&forMarshaling->commandBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkSubmitInfo2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSubmitFlagsKHR*)&forMarshaling->flags, sizeof(VkSubmitFlagsKHR));
    *ptr += sizeof(VkSubmitFlagsKHR);
    memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
        reservedmarshal_VkSemaphoreSubmitInfoKHR(
            vkStream, rootType,
            (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
        reservedmarshal_VkCommandBufferSubmitInfoKHR(
            vkStream, rootType,
            (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
        reservedmarshal_VkSemaphoreSubmitInfoKHR(
            vkStream, rootType,
            (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i), ptr);
    }
}

void reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkQueueFamilyCheckpointProperties2NV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
}

void reservedmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkCheckpointData2NV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stage,
           sizeof(VkPipelineStageFlags2KHR));
    *ptr += sizeof(VkPipelineStageFlags2KHR);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pCheckpointMarker) {
        memcpy(*ptr, (void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
        *ptr += sizeof(uint8_t);
    }
}

#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void reservedmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling,
    uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupUniformControlFlow, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void reservedmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_KHR_copy_commands2
void reservedmarshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkBufferCopy2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkCopyBufferInfo2KHR* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->srcBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkBuffer((*&forMarshaling->dstBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkBufferCopy2KHR(
            vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i), ptr);
    }
}

void reservedmarshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                     const VkImageCopy2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}

void reservedmarshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkCopyImageInfo2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkImageCopy2KHR(vkStream, rootType,
                                        (const VkImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
    }
}

void reservedmarshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkBufferImageCopy2KHR* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
}

void reservedmarshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkCopyBufferToImageInfo2KHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->srcBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkBufferImageCopy2KHR(
            vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
    }
}

void reservedmarshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkCopyImageToBufferInfo2KHR* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkBuffer((*&forMarshaling->dstBuffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkBufferImageCopy2KHR(
            vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
    }
}

void reservedmarshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                     const VkImageBlit2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i),
                                   ptr);
    }
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
        reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i),
                                   ptr);
    }
}

void reservedmarshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkBlitImageInfo2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkImageBlit2KHR(vkStream, rootType,
                                        (const VkImageBlit2KHR*)(forMarshaling->pRegions + i), ptr);
    }
    memcpy(*ptr, (VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
    *ptr += sizeof(VkFilter);
}

void reservedmarshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                        const VkImageResolve2KHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
    reservedmarshal_VkImageSubresourceLayers(
        vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
    reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
    reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}

void reservedmarshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkResolveImageInfo2KHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
    *ptr += sizeof(VkImageLayout);
    memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
        reservedmarshal_VkImageResolve2KHR(
            vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i), ptr);
    }
}

#endif
#ifdef VK_KHR_format_feature_flags2
void reservedmarshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                            const VkFormatProperties3KHR* forMarshaling,
                                            uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures,
           sizeof(VkFormatFeatureFlags2KHR));
    *ptr += sizeof(VkFormatFeatureFlags2KHR);
    memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures,
           sizeof(VkFormatFeatureFlags2KHR));
    *ptr += sizeof(VkFormatFeatureFlags2KHR);
    memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures,
           sizeof(VkFormatFeatureFlags2KHR));
    *ptr += sizeof(VkFormatFeatureFlags2KHR);
}

#endif
#ifdef VK_KHR_maintenance4
void reservedmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
}

void reservedmarshal_VkDeviceBufferMemoryRequirementsKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceBufferMemoryRequirementsKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkBufferCreateInfo(
        vkStream, rootType, (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo), ptr);
}

void reservedmarshal_VkDeviceImageMemoryRequirementsKHR(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDeviceImageMemoryRequirementsKHR* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkImageCreateInfo(vkStream, rootType,
                                      (const VkImageCreateInfo*)(forMarshaling->pCreateInfo), ptr);
    memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
           sizeof(VkImageAspectFlagBits));
    *ptr += sizeof(VkImageAspectFlagBits);
}

#endif
#ifdef VK_ANDROID_native_buffer
void reservedmarshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkNativeBufferANDROID* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->handle) {
        memcpy(*ptr, (const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
        *ptr += sizeof(const uint32_t);
    }
    memcpy(*ptr, (int*)&forMarshaling->stride, sizeof(int));
    *ptr += sizeof(int);
    memcpy(*ptr, (int*)&forMarshaling->format, sizeof(int));
    *ptr += sizeof(int);
    memcpy(*ptr, (int*)&forMarshaling->usage, sizeof(int));
    *ptr += sizeof(int);
    memcpy(*ptr, (uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

#endif
#ifdef VK_EXT_debug_report
void reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDebugReportCallbackCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
    *ptr += sizeof(VkDebugReportFlagsEXT);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnCallback;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pUserData) {
        memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
        *ptr += 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 reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder,
           sizeof(VkRasterizationOrderAMD));
    *ptr += sizeof(VkRasterizationOrderAMD);
}

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDebugMarkerObjectNameInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
           sizeof(VkDebugReportObjectTypeEXT));
    *ptr += sizeof(VkDebugReportObjectTypeEXT);
    memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    {
        uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->pObjectName, l);
        *ptr += l;
    }
}

void reservedmarshal_VkDebugMarkerObjectTagInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDebugMarkerObjectTagInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
           sizeof(VkDebugReportObjectTypeEXT));
    *ptr += sizeof(VkDebugReportObjectTypeEXT);
    memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
    *ptr += forMarshaling->tagSize * sizeof(const uint8_t);
}

void reservedmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream,
                                                VkStructureType rootType,
                                                const VkDebugMarkerMarkerInfoEXT* forMarshaling,
                                                uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    {
        uint32_t l = forMarshaling->pMarkerName ? strlen(forMarshaling->pMarkerName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->pMarkerName, l);
        *ptr += l;
    }
    memcpy(*ptr, (float*)forMarshaling->color, 4 * sizeof(float));
    *ptr += 4 * sizeof(float);
}

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationImageCreateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
}

#endif
#ifdef VK_EXT_transform_feedback
void reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedback, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->geometryStreams, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize,
           sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackStreamDataSize, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataSize, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataStride, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackQueries, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackDraw, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
    *ptr += sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT);
    memcpy(*ptr, (uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

#endif
#ifdef VK_NVX_binary_import
void reservedmarshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkCuModuleCreateInfoNVX* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (const void*)forMarshaling->pData,
           forMarshaling->dataSize * sizeof(const uint8_t));
    *ptr += forMarshaling->dataSize * sizeof(const uint8_t);
}

void reservedmarshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkCuFunctionCreateInfoNVX* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->module;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    {
        uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->pName, l);
        *ptr += l;
    }
}

void reservedmarshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const VkCuLaunchInfoNVX* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->function;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    memcpy(*ptr, (uint32_t*)&forMarshaling->gridDimX, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->gridDimY, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->gridDimZ, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->blockDimX, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->blockDimY, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->blockDimZ, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->sharedMemBytes, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->paramCount;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_2 = (uint64_t)forMarshaling->extraCount;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

#endif
#ifdef VK_NVX_image_view_handle
void reservedmarshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkImageViewHandleInfoNVX* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
    *ptr += sizeof(VkDescriptorType);
    uint64_t cgen_var_1;
    *&cgen_var_1 = get_host_u64_VkSampler((*&forMarshaling->sampler));
    memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
    *ptr += 1 * 8;
}

void reservedmarshal_VkImageViewAddressPropertiesNVX(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImageViewAddressPropertiesNVX* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
    *ptr += sizeof(VkDeviceAddress);
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
    *ptr += 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 reservedmarshal_VkVideoEncodeH264CapabilitiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags,
           sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH264CapabilityFlagsEXT);
    memcpy(*ptr, (VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
           sizeof(VkVideoEncodeH264InputModeFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH264InputModeFlagsEXT);
    memcpy(*ptr, (VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
           sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH264OutputModeFlagsEXT);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->minPictureSizeInMbs), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}

void reservedmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkVideoEncodeH264CreateFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH264CreateFlagsEXT);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
        ptr);
}

void reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSpsStd) {
        memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
               forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
        *ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pPpsStd) {
        memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
               forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
        *ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
    }
}

void reservedmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pParametersAddInfo) {
        reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling
                                                                      ->pParametersAddInfo),
            ptr);
    }
}

void reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
    *ptr += sizeof(int8_t);
    memcpy(*ptr, (const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
           sizeof(const StdVideoEncodeH264PictureInfo));
    *ptr += sizeof(const StdVideoEncodeH264PictureInfo);
}

void reservedmarshal_VkVideoEncodeH264NaluSliceEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264NaluSliceEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd,
           sizeof(const StdVideoEncodeH264SliceHeader));
    *ptr += sizeof(const StdVideoEncodeH264SliceHeader);
    memcpy(*ptr, (uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->refFinalList0EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i),
            ptr);
    }
    memcpy(*ptr, (uint8_t*)&forMarshaling->refFinalList1EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->precedingNaluBytes, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->minQp, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxQp, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
}

void reservedmarshal_VkVideoEncodeH264VclFrameInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList0Entries +
                                                     i),
            ptr);
    }
    memcpy(*ptr, (uint8_t*)&forMarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList1Entries +
                                                     i),
            ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH264NaluSliceEXT(
            vkStream, rootType,
            (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
    }
    reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
        vkStream, rootType,
        (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo), ptr);
}

void reservedmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->spsId, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries,
           forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
    *ptr += forMarshaling->ppsIdEntryCount * sizeof(const uint8_t);
}

void reservedmarshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkVideoEncodeH264ProfileEXT* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
           sizeof(StdVideoH264ProfileIdc));
    *ptr += sizeof(StdVideoH264ProfileIdc);
}

#endif
#ifdef VK_EXT_video_encode_h265
void reservedmarshal_VkVideoEncodeH265CapabilitiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
           sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH265CapabilityFlagsEXT);
    memcpy(*ptr, (VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
           sizeof(VkVideoEncodeH265InputModeFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH265InputModeFlagsEXT);
    memcpy(*ptr, (VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
           sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH265OutputModeFlagsEXT);
    memcpy(*ptr, (VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
           sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH265CtbSizeFlagsEXT);
    reservedmarshal_VkExtent2D(vkStream, rootType,
                               (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumSubLayers, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}

void reservedmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkVideoEncodeH265CreateFlagsEXT));
    *ptr += sizeof(VkVideoEncodeH265CreateFlagsEXT);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
        ptr);
}

void reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->vpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVpsStd;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pVpsStd) {
        memcpy(*ptr, (const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd,
               forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
        *ptr += forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSpsStd) {
        memcpy(*ptr, (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
               forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
        *ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
    memcpy((*ptr), &cgen_var_2, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pPpsStd) {
        memcpy(*ptr, (const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
               forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
        *ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
    }
}

void reservedmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxVpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pParametersAddInfo) {
        reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling
                                                                      ->pParametersAddInfo),
            ptr);
    }
}

void reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
    *ptr += sizeof(int8_t);
    memcpy(*ptr, (const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
           sizeof(const StdVideoEncodeH265ReferenceInfo));
    *ptr += sizeof(const StdVideoEncodeH265ReferenceInfo);
}

void reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265ReferenceListsEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->referenceList0EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries + i),
            ptr);
    }
    memcpy(*ptr, (uint8_t*)&forMarshaling->referenceList1EntryCount, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries + i),
            ptr);
    }
    memcpy(*ptr,
           (const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications,
           sizeof(const StdVideoEncodeH265ReferenceModifications));
    *ptr += sizeof(const StdVideoEncodeH265ReferenceModifications);
}

void reservedmarshal_VkVideoEncodeH265NaluSliceEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265NaluSliceEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->ctbCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pReferenceFinalLists) {
        reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
    }
    memcpy(*ptr, (const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd,
           sizeof(const StdVideoEncodeH265SliceHeader));
    *ptr += sizeof(const StdVideoEncodeH265SliceHeader);
}

void reservedmarshal_VkVideoEncodeH265VclFrameInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pReferenceFinalLists) {
        reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
        reservedmarshal_VkVideoEncodeH265NaluSliceEXT(
            vkStream, rootType,
            (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
    }
    memcpy(*ptr, (const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo,
           sizeof(const StdVideoEncodeH265PictureInfo));
    *ptr += sizeof(const StdVideoEncodeH265PictureInfo);
}

void reservedmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint8_t*)&forMarshaling->vpsId, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (uint8_t*)&forMarshaling->spsId, sizeof(uint8_t));
    *ptr += sizeof(uint8_t);
    memcpy(*ptr, (VkBool32*)&forMarshaling->emitVpsEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries,
           forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
    *ptr += forMarshaling->ppsIdEntryCount * sizeof(const uint8_t);
}

void reservedmarshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkVideoEncodeH265ProfileEXT* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
           sizeof(StdVideoH265ProfileIdc));
    *ptr += sizeof(StdVideoH265ProfileIdc);
}

#endif
#ifdef VK_EXT_video_decode_h264
void reservedmarshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkVideoDecodeH264ProfileEXT* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
           sizeof(StdVideoH264ProfileIdc));
    *ptr += sizeof(StdVideoH264ProfileIdc);
    memcpy(*ptr, (VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout,
           sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
    *ptr += sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT);
}

void reservedmarshal_VkVideoDecodeH264CapabilitiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkOffset2D(vkStream, rootType,
                               (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity), ptr);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}

void reservedmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkVideoDecodeH264CreateFlagsEXT));
    *ptr += sizeof(VkVideoDecodeH264CreateFlagsEXT);
    reservedmarshal_VkExtensionProperties(
        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
        ptr);
}

void reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pSpsStd) {
        memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
               forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
        *ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
    }
    memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pPpsStd) {
        memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
               forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
        *ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
    }
}

void reservedmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pParametersAddInfo) {
        reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
            vkStream, rootType,
            (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling
                                                                      ->pParametersAddInfo),
            ptr);
    }
}

void reservedmarshal_VkVideoDecodeH264PictureInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264PictureInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
           sizeof(const StdVideoDecodeH264PictureInfo));
    *ptr += sizeof(const StdVideoDecodeH264PictureInfo);
    memcpy(*ptr, (uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pSlicesDataOffsets,
           forMarshaling->slicesCount * sizeof(const uint32_t));
    *ptr += forMarshaling->slicesCount * sizeof(const uint32_t);
}

void reservedmarshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkVideoDecodeH264MvcEXT* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc,
           sizeof(const StdVideoDecodeH264Mvc));
    *ptr += sizeof(const StdVideoDecodeH264Mvc);
}

void reservedmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
           sizeof(const StdVideoDecodeH264ReferenceInfo));
    *ptr += sizeof(const StdVideoDecodeH264ReferenceInfo);
}

#endif
#ifdef VK_AMD_texture_gather_bias_lod
void reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkTextureLODGatherFormatPropertiesAMD* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_AMD_shader_info
void reservedmarshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkShaderResourceUsageAMD* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    uint64_t cgen_var_0 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    uint64_t cgen_var_1 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
    memcpy((*ptr), &cgen_var_1, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
}

void reservedmarshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkShaderStatisticsInfoAMD* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
    *ptr += sizeof(VkShaderStageFlags);
    reservedmarshal_VkShaderResourceUsageAMD(
        vkStream, rootType, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage), ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->numPhysicalVgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->numPhysicalSgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->numAvailableVgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->numAvailableSgprs, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)forMarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
    *ptr += 3 * sizeof(uint32_t);
}

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags,
           sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
    *ptr += sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP);
    memcpy(*ptr, (GgpStreamDescriptor*)&forMarshaling->streamDescriptor,
           sizeof(GgpStreamDescriptor));
    *ptr += sizeof(GgpStreamDescriptor);
}

#endif
#ifdef VK_NV_corner_sampled_image
void reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->cornerSampledImage, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void reservedmarshal_VkExternalImageFormatPropertiesNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalImageFormatPropertiesNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    reservedmarshal_VkImageFormatProperties(
        vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
    memcpy(*ptr, (VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures,
           sizeof(VkExternalMemoryFeatureFlagsNV));
    *ptr += sizeof(VkExternalMemoryFeatureFlagsNV);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes,
           sizeof(VkExternalMemoryHandleTypeFlagsNV));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes,
           sizeof(VkExternalMemoryHandleTypeFlagsNV));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}

#endif
#ifdef VK_NV_external_memory
void reservedmarshal_VkExternalMemoryImageCreateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExternalMemoryImageCreateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
           sizeof(VkExternalMemoryHandleTypeFlagsNV));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}

void reservedmarshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkExportMemoryAllocateInfoNV* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
           sizeof(VkExternalMemoryHandleTypeFlagsNV));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}

#endif
#ifdef VK_NV_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkImportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType,
           sizeof(VkExternalMemoryHandleTypeFlagsNV));
    *ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
    memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
    *ptr += sizeof(HANDLE);
}

void reservedmarshal_VkExportMemoryWin32HandleInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkExportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pAttributes) {
        memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
               sizeof(const SECURITY_ATTRIBUTES));
        *ptr += sizeof(const SECURITY_ATTRIBUTES);
    }
    memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
    *ptr += sizeof(DWORD);
}

#endif
#ifdef VK_NV_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->acquireCount) {
        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pAcquireSyncs[k]);
                memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->acquireCount;
    }
    memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys,
           forMarshaling->acquireCount * sizeof(const uint64_t));
    *ptr += forMarshaling->acquireCount * sizeof(const uint64_t);
    memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds,
           forMarshaling->acquireCount * sizeof(const uint32_t));
    *ptr += forMarshaling->acquireCount * sizeof(const uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    if (forMarshaling->releaseCount) {
        uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
        if (forMarshaling) {
            for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k) {
                uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pReleaseSyncs[k]);
                memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
            }
        }
        *ptr += 8 * forMarshaling->releaseCount;
    }
    memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys,
           forMarshaling->releaseCount * sizeof(const uint64_t));
    *ptr += forMarshaling->releaseCount * sizeof(const uint64_t);
}

#endif
#ifdef VK_EXT_validation_flags
void reservedmarshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkValidationFlagsEXT* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->disabledValidationCheckCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks,
           forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
    *ptr += forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT);
}

#endif
#ifdef VK_NN_vi_surface
void reservedmarshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                             const VkViSurfaceCreateInfoNN* forMarshaling,
                                             uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkViSurfaceCreateFlagsNN*)&forMarshaling->flags,
           sizeof(VkViSurfaceCreateFlagsNN));
    *ptr += sizeof(VkViSurfaceCreateFlagsNN);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->window) {
        memcpy(*ptr, (void*)forMarshaling->window, sizeof(uint8_t));
        *ptr += sizeof(uint8_t);
    }
}

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_EXT_astc_decode_mode
void reservedmarshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkImageViewASTCDecodeModeEXT* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
    *ptr += sizeof(VkFormat);
}

void reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_EXT_conditional_rendering
void reservedmarshal_VkConditionalRenderingBeginInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkConditionalRenderingBeginInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    uint64_t cgen_var_0;
    *&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
    memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
    *ptr += 1 * 8;
    memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
    *ptr += sizeof(VkDeviceSize);
    memcpy(*ptr, (VkConditionalRenderingFlagsEXT*)&forMarshaling->flags,
           sizeof(VkConditionalRenderingFlagsEXT));
    *ptr += sizeof(VkConditionalRenderingFlagsEXT);
}

void reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_NV_clip_space_w_scaling
void reservedmarshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkViewportWScalingNV* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (float*)&forMarshaling->xcoeff, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->ycoeff, sizeof(float));
    *ptr += sizeof(float);
}

void reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pViewportWScalings) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
            reservedmarshal_VkViewportWScalingNV(
                vkStream, rootType,
                (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i), ptr);
        }
    }
}

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
void reservedmarshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkSurfaceCapabilities2EXT* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent),
                               ptr);
    reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent),
                               ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
           sizeof(VkSurfaceTransformFlagsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagsKHR);
    memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
           sizeof(VkSurfaceTransformFlagBitsKHR));
    *ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
    memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
           sizeof(VkCompositeAlphaFlagsKHR));
    *ptr += sizeof(VkCompositeAlphaFlagsKHR);
    memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
           sizeof(VkImageUsageFlags));
    *ptr += sizeof(VkImageUsageFlags);
    memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters,
           sizeof(VkSurfaceCounterFlagsEXT));
    *ptr += sizeof(VkSurfaceCounterFlagsEXT);
}

#endif
#ifdef VK_EXT_display_control
void reservedmarshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkDisplayPowerInfoEXT* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDisplayPowerStateEXT*)&forMarshaling->powerState,
           sizeof(VkDisplayPowerStateEXT));
    *ptr += sizeof(VkDisplayPowerStateEXT);
}

void reservedmarshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkDeviceEventInfoEXT* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
    *ptr += sizeof(VkDeviceEventTypeEXT);
}

void reservedmarshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                           const VkDisplayEventInfoEXT* forMarshaling,
                                           uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkDisplayEventTypeEXT*)&forMarshaling->displayEvent,
           sizeof(VkDisplayEventTypeEXT));
    *ptr += sizeof(VkDisplayEventTypeEXT);
}

void reservedmarshal_VkSwapchainCounterCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkSwapchainCounterCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters,
           sizeof(VkSurfaceCounterFlagsEXT));
    *ptr += sizeof(VkSurfaceCounterFlagsEXT);
}

#endif
#ifdef VK_GOOGLE_display_timing
void reservedmarshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream,
                                                  VkStructureType rootType,
                                                  const VkRefreshCycleDurationGOOGLE* forMarshaling,
                                                  uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkPastPresentationTimingGOOGLE(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPastPresentationTimingGOOGLE* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->actualPresentTime, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->earliestPresentTime, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->presentMargin, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkPresentTimeGOOGLE* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    memcpy(*ptr, (uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
    *ptr += sizeof(uint64_t);
}

void reservedmarshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                              const VkPresentTimesInfoGOOGLE* forMarshaling,
                                              uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pTimes) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
            reservedmarshal_VkPresentTimeGOOGLE(
                vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i), ptr);
        }
    }
}

#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 reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_NV_viewport_swizzle
void reservedmarshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                         const VkViewportSwizzleNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->x,
           sizeof(VkViewportCoordinateSwizzleNV));
    *ptr += sizeof(VkViewportCoordinateSwizzleNV);
    memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->y,
           sizeof(VkViewportCoordinateSwizzleNV));
    *ptr += sizeof(VkViewportCoordinateSwizzleNV);
    memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->z,
           sizeof(VkViewportCoordinateSwizzleNV));
    *ptr += sizeof(VkViewportCoordinateSwizzleNV);
    memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->w,
           sizeof(VkViewportCoordinateSwizzleNV));
    *ptr += sizeof(VkViewportCoordinateSwizzleNV);
}

void reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags,
           sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
    *ptr += sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV);
    memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pViewportSwizzles) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
            reservedmarshal_VkViewportSwizzleNV(
                vkStream, rootType,
                (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i), ptr);
        }
    }
}

#endif
#ifdef VK_EXT_discard_rectangles
void reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
}

void reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
    *ptr += sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT);
    memcpy(*ptr, (VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode,
           sizeof(VkDiscardRectangleModeEXT));
    *ptr += sizeof(VkDiscardRectangleModeEXT);
    memcpy(*ptr, (uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
    *ptr += sizeof(uint32_t);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pDiscardRectangles) {
        for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i) {
            reservedmarshal_VkRect2D(vkStream, rootType,
                                     (const VkRect2D*)(forMarshaling->pDiscardRectangles + i), ptr);
        }
    }
}

#endif
#ifdef VK_EXT_conservative_rasterization
void reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity,
           sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->conservativePointAndLineRasterization,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
    memcpy(*ptr, (VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage,
           sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
    *ptr += sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT);
    memcpy(*ptr, (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode,
           sizeof(VkConservativeRasterizationModeEXT));
    *ptr += sizeof(VkConservativeRasterizationModeEXT);
    memcpy(*ptr, (float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
    *ptr += sizeof(float);
}

#endif
#ifdef VK_EXT_depth_clip_enable
void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
           sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
    *ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
    memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
    *ptr += sizeof(VkBool32);
}

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void reservedmarshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                  const VkXYColorEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->y, sizeof(float));
    *ptr += sizeof(float);
}

void reservedmarshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                      const VkHdrMetadataEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    reservedmarshal_VkXYColorEXT(vkStream, rootType,
                                 (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed), ptr);
    reservedmarshal_VkXYColorEXT(vkStream, rootType,
                                 (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen), ptr);
    reservedmarshal_VkXYColorEXT(vkStream, rootType,
                                 (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue), ptr);
    reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->whitePoint),
                                 ptr);
    memcpy(*ptr, (float*)&forMarshaling->maxLuminance, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->minLuminance, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->maxContentLightLevel, sizeof(float));
    *ptr += sizeof(float);
    memcpy(*ptr, (float*)&forMarshaling->maxFrameAverageLightLevel, sizeof(float));
    *ptr += sizeof(float);
}

#endif
#ifdef VK_MVK_ios_surface
void reservedmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
                                               VkStructureType rootType,
                                               const VkIOSSurfaceCreateInfoMVK* forMarshaling,
                                               uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
           sizeof(VkIOSSurfaceCreateFlagsMVK));
    *ptr += sizeof(VkIOSSurfaceCreateFlagsMVK);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pView) {
        memcpy(*ptr, (const void*)forMarshaling->pView, sizeof(const uint8_t));
        *ptr += sizeof(const uint8_t);
    }
}

#endif
#ifdef VK_MVK_macos_surface
void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
                                                 VkStructureType rootType,
                                                 const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
                                                 uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
           sizeof(VkMacOSSurfaceCreateFlagsMVK));
    *ptr += sizeof(VkMacOSSurfaceCreateFlagsMVK);
    // WARNING PTR CHECK
    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
    memcpy((*ptr), &cgen_var_0, 8);
    android::base::Stream::toBe64((uint8_t*)(*ptr));
    *ptr += 8;
    if (forMarshaling->pView) {
        memcpy(*ptr, (const void*)forMarshaling->pView, sizeof(const uint8_t));
        *ptr += sizeof(const uint8_t);
    }
}

#endif
#ifdef VK_MVK_moltenvk
#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void reservedmarshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                          const VkDebugUtilsLabelEXT* forMarshaling,
                                          uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    {
        uint32_t l = forMarshaling->pLabelName ? strlen(forMarshaling->pLabelName) : 0;
        memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
        android::base::Stream::toBe32((uint8_t*)*ptr);
        *ptr += sizeof(uint32_t);
        memcpy(*ptr, (char*)forMarshaling->pLabelName, l);
        *ptr += l;
    }
    memcpy(*ptr, (float*)forMarshaling->color, 4 * sizeof(float));
    *ptr += 4 * sizeof(float);
}

void reservedmarshal_VkDebugUtilsObjectNameInfoEXT(
    VulkanStreamGuest* vkStream, VkStructureType rootType,
    const VkDebugUtilsObjectNameInfoEXT* forMarshaling, uint8_t** ptr) {
    (void)vkStream;
    (void)rootType;
    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
    *ptr += sizeof(VkStructureType);
    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
        rootType = forMarshaling->sType;
    }
    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
    memcpy(*ptr, (VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
    *ptr += sizeof(VkObjectType);
    memcpy(*ptr, (uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
    *ptr += 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;
        memcpy((*ptr), &cgen_var_0, 8);
        android::base::Stream::toBe64((uint8_t*)(*ptr));
        *ptr += 8;
        if (forMarshaling->pObjectName) {
            {
                uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
                memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
                android::base::Stream::toBe32((uint8_t*)*ptr);
                *ptr += sizeof(uint32_t);
                memcpy(*ptr, (char*)forMarshaling->pObjectName, l);
                *ptr += l;
            }
        }
    } else {
        {
            uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
            memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));</